The document discusses best practices for managing database migrations and seeds in Laravel projects. It recommends: - Using migrations only for database schema changes and keeping them simple and reversible. - Categorizing seeds into different types for settings, testing data, and development data. Seeds can insert data and call other seeds. - Sharing migrations and seeds between projects using a Composer package for the database files. This allows multiple projects to use the same database schema. - Following strategies like truncation for development seeds and append-only for settings to prevent issues from duplicate data. - Defensively coding seeds to prevent running in production and only insert required data. Well maintained migrations and seeds

1. AVOIDING DATABASE MIGRATION
HELLby Edward Coleridge Smith

2. jedatron
edcs

3. WHAT IS A DATABASEMIGRATION?
on is an incremental and reversible change to

4. WHY USE DATABASEMIGRATIONS?
The Schema is Part of the Project
When you checkout a copy of the project, you get a copy
of the database schema too

5. WHY USE DATABASEMIGRATIONS?
No Need To Access Production Environments
Your database schema is part of your applications source
code
No need to log into your production database and grab
SQL dumps

6. WHY USE DATABASEMIGRATIONS?
The Database Schema is Versioned
The database schema is versioned with your application
source code
Migrations run in both directions so you can revert your
database schema back to any point in time

7. WHY USE DATABASEMIGRATIONS?
Dev & Production Environments Will Match
Since your database schema is described using code,
your database schema will be created in a repeatable and
predictable manner

8. WHY USE DATABASEMIGRATIONS?
Great For Testing!
Your test suite can create and destroy a database on the
fly and on demand

9. HOW DO I MAKE A MIGRATION?
Live Demo

10. <?php
use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
class CreateRolesTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('roles', function (Blueprint $table) {
});
}
WHAT DOES A MIGRATION LOOKLIKE?

11. <?php
use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
class CreateRolesTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('roles', function (Blueprint $table) {
$table->string('id');
$table->timestamps();
$table->softDeletes();
$table->primary('id');
});
}
WHAT DOES A MIGRATION LOOKLIKE?

12. WHAT IS A DATABASE SEED?
ed automatically inserts data into an applicati

13. WHY USE DATABASE SEEDS?
Makes Your Application Feel ‘Real’
Have you ever had to sign up to your own app during
development?
Have you ever had to insert a few rows into the database
for test runs?

14. WHY USE DATABASE SEEDS?
Production Data Stays In Production
Are you using a local copy of your production database for
development?

15. WHY USE DATABASE SEEDS?
Great For Testing!
You can quickly seed your database so your application is
ready for functional and acceptance tests

16. WHY USE DATABASE SEEDS?
Great For Inserting Application Settings
Does your application have settings like roles or scopes
which need to be in the database for it to work?

17. HOW DO I MAKE A SEED?
Live Demo

18. <?php
use IlluminateDatabaseSeeder;
class RolesTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
}
}
WHAT DOES A SEED LOOK LIKE?

19. <?php
use IlluminateDatabaseSeeder;
use IlluminateSupportFacadesDB;
use VascLabApiRole;
class RolesTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
DB::table('roles')->insert([
['id' => Role::ACCOUNT_ADMIN],
['id' => Role::REPORTS],
['id' => Role::REPORTS_READ],
['id' => Role::SUBSCRIPTION_ADMIN],
['id' => Role::MAIN_CONTACT]
]);
}
}
WHAT DOES A SEED LOOK LIKE?

20. <?php
use CarbonCarbon;
use IlluminateDatabaseSeeder;
use VascLabApiUser;
class UsersTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
User::create([
'salutation' => 'Mr',
'firstname' => 'Edward',
'lastname' => 'Coleridge Smith',
'email' => 'e.coleridgesmith@edcs.me',
'password' => bcrypt('password'),
'activated_at' => Carbon::now()
]);
}
}
WHAT DOES A SEED LOOK LIKE?

21. <?php
use IlluminateDatabaseSeeder;
use VascLabApiOrganisation;
class OrganisationsTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
factory(Organisation::class, 5)->create();
}
}
WHAT DOES A SEED LOOK LIKE?

22. WHAT DOES A SEED LOOK LIKE?
<?php
use IlluminateDatabaseSeeder;
class DevelopmentSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
$this->call(UsersTableSeeder::class);
$this->call(OrganisationsTableSeeder::class);
}
}

23. MODEL FACTORIES IN LARAVEL
<?php
/** @var $factory IlluminateDatabaseEloquentFactory */
use VascLabApiOrganisation;
$factory->define(Organisation::class, function (FakerGenerator $faker) {
$faker->addProvider(new FakerProvideren_GBAddress($faker));
return [
'name' => $faker->company,
'business_name' => $faker->company,
'address_1' => $faker->buildingNumber,
'address_2' => $faker->streetName,
'postal_town' => $faker->city,
'postcode' => $faker->postcode,
'country' => 'GB'
];
});

24. CATEGORISING YOUR SEEDS
Database Settings Seeds for Testing
Seeds for
Development or Demos
What Kinds of Data?
Entries which are required in
your database at all times
Entries which are required in
your database during testing
Faked data which can be use
by your developers or for
demos
How Much Data?
Data that’s required for your
application to work which
can’t live in config files
The bare minimum amount of
data that’s needed to test
your application
As much fake data as need
to make your application feel
‘real’
When Should
They Run?
Whenever you deploy and
update to your application
Before you run your tests
Manually run whenever you
need ‘fresh’ data

25. CATEGORISING YOUR SEEDS
Database Settings
Should contain entries which are required in your
database at all times
Should only seed data which is required for your
application to work and cannot live in a configuration file
Should be run whenever you deploy an update to your
application

26. CATEGORISING YOUR SEEDS
Seeds For Testing
Should contain a small sample of data required to run
tests against your application
Should be the bare minimum required for you application
to run
Should be run before you run your application test suite

27. CATEGORISING YOUR SEEDS
Seeds For Development and Demos
faked data which can be used for development and demo runs of y
uld contain as much fake data needed to make your application feel
be run on an ad-hoc basis whenever you need fresh data in your ap

28. DATABASE SEED STRATEGIES
Truncate Append
Remove all existing data from table
first
then re-seed
Check if row already exists in table
only add record if it doesn’t

29. DATABASE SEED STRATEGIES
Truncate
Remove all existing data from table
first
then re-seed

30. DATABASE SEED STRATEGIES
Append
Check if row already exists in table
only add record if it doesn’t

31. DATABASE SEED STRATEGIES
Truncate Append
Generally used for inserting data
used for development and testing
Generally used for settings that are
needed in both dev and production

32. WAIT, WHY NOT USEMIGRATIONS?
• A migration can only ever run once, unless
you refresh your database
• As your applications grow you’ll probably
need more settings
• More settings means more migrations
• Things get out of control fast!

33. Fixing This Was Not Fun!
WAIT, WHY NOT USEMIGRATIONS?

34. TRUNCATION STRATEGY SEEDS
DB::table($table)->truncate();
DB::statement('SET foreign_key_checks = 0');
DB::statement('SET foreign_key_checks = 1');

35. <?php
class DevelopmentSeeder extends Seeder
{
/**
* The tables which are affected by this seed.
*
* @var array
*/
protected $tables = [
'organisations',
'organisation_user',
'role_user',
'users',
'patients',
'reports',
'report_revisions',
'oauth_access_tokens',
'oauth_access_token_scope'
];
TRUNCATION STRATEGY SEEDS

36. TRUNCATION STRATEGY SEEDS
<?php
use IlluminateDatabaseSeeder;
use VascLabApiOrganisation;
class OrganisationsTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
factory(Organisation::class, 5)->create();
}
}

37. <?php
class DatabaseSeeder extends Seeder
{
/**
* The individual table seeders which should be run.
*
* @var array
*/
protected $seeds = [
RolesTableSeeder::class,
OauthGrantsTableSeeder::class,
OauthClientsTableSeeder::class,
OauthScopesTableSeeder::class
];
/**
* Run the database seeds.
*
* @return void
APPEND STRATEGY SEEDS

38. <?php
use CarbonCarbon;
use IlluminateDatabaseSeeder;
class OauthGrantsTableSeeder extends Seeder
{
/**
* The grants which are being created.
*
* @var array
*/
private $grants = [
'password',
'refresh_token',
'client_credentials'
];
/**
APPEND STRATEGY SEEDS

39. protected $tables = [];
/**
* The individual table seeders which should be run.
*
* @var array
*/
protected $seeds = [];
/**
* Ensures that the app is running in a development or test environment.
*
* @return void
*/
protected function shouldSeedsBeRun()
{
if (app()->environment() === 'production') {
$this->command->getOutput()->writeln(
"<error>This seeder cannot be run in production.</error>"
);
die;
}
}
/**
CODE DEFENSIVELY

40. PUTTING IT ALL TOGETHER
Live Demo

41. use CarbonCarbon;
use IlluminateDatabaseMigrationsMigration;
class InsertMissingSoloUnits extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
// Don't run this migration during testing
if (App::runningUnitTests()) {
return;
}
DB::unprepared(File::get(app_path() . '/../database/2015-07-16.sql'));
$pods = DB::table(‘__psl_part_numbers')
->join('pod_models', '__psl_part_numbers.model', '=', 'pod_models.name')
->join('pod_connectors', 'pod_models.id', '=', 'pod_connectors.model_id')
->get([
'__psl_part_numbers.psl_number AS ppid',
'__psl_part_numbers.sim_number AS sim_number',
PRO TIP, KEEP IT SIMPLE

42. THINGS ARE GOING WELL! WE NEED ANAPP…
• You’ve built an awesome product with Laravel
and business is going great!
• Your team has decided that it’s time to branch
out and build something with React Native
• You now need a ReST API to go alongside
your traditional web app
• Both products need to speak to the same
database…

43. COMPOSER TO THE RESCUE!
• We can use a Composer package to share
migrations and seeds between our projects
• Composer can access and install packages
from private Git repos
• Your original web app can install your
database as a main dependancy
• Your ReST API can install your database as a
dev dependancy

44. DATABASE PACKAGES
Web App ReST API
In charge of the production
database
Runs migrations and seeds in dev
and production environments
Only reads from production
database
Runs migrations and seeds in dev,
testing and staging environments

45. vagrant@homestead:~/Code/PP/database$ tree
.
|____composer.json
|____migrations
| |____2014_10_12_000000_create_users_table.php
| |____...
|____README.md
|____src
| |____Seeds
| | |____DatabaseSeeder.php
| | |____DevelopmentSeeder.php
| | |____Development
| | | |____UsersTableSeeder.php
| | | |____...
| | |____Production
| | | |____RolesTableSeeder.php
| | | |____...
STRUCTURING YOUR COMPOSERPACKAGE

46. SETTING UP THE COMPOSER PACKAGE
{
"name": "pod-point/database",
"description": "Migrations and seeds for the POD Point database",
"license": "proprietary",
"type": "library",
...
"autoload": {
"classmap": [
"migrations"
],
"psr-4": {
"PodPointDatabase": "src/"
}
}
}

47. {
"name": "pod-point/mis",
"description": "The POD Point MIS",
"license": "proprietary",
"type": "project",
"repositories": [
{
"type": "git",
"url": "git@github.com:pod-point/database.git"
}
],
"require": {
"pod-point/database": "^1.1",
...
},
...
}
INSTALLING THE COMPOSER PACKAGE

48. <?php
namespace PodPointInstallsWebAppProviders;
use IlluminateDatabaseEloquentFactory;
use IlluminateSupportServiceProvider;
class AppServiceProvider extends ServiceProvider
{
/**
* Bootstrap the application services.
*
* @return void
*/
public function boot()
{
$this->app->useDatabasePath(base_path('vendor/app/database/'));
}
/**
* Register the application services.
*
LARAVEL CONFIGURATION

49. INSTALLING THE COMPOSER PACKAGE
{
"name": "pod-point/api",
"description": "The POD Point API",
"license": "proprietary",
"type": "project",
"repositories": [
{
"type": "git",
"url": "git@github.com:pod-point/database.git"
}
],
...,
"require-dev": {
"pod-point/database": "^1.1",
...
}
}

50. <?php
namespace PodPointInstallsWebAppProviders;
use IlluminateDatabaseEloquentFactory;
use IlluminateSupportServiceProvider;
class AppServiceProvider extends ServiceProvider
{
/**
* Bootstrap the application services.
*
* @return void
*/
public function boot()
{
$this->app->useDatabasePath(base_path('vendor/app/database/'));
}
/**
* Register the application services.
*
LARAVEL CONFIGURATION

51. DATABASE PACKAGES
Web App ReST API
In charge of the production
database
Runs migrations and seeds in dev
and production environments
Only reads from production
database
Runs migrations and seeds in dev,
testing and staging environments

52. SUMMARY
Top Tips For Database Migrations
Only use migrations to manage your database schema
Avoid using raw SQL in your migrations at all costs
Keep your migrations as simple as possible

53. SUMMARY
Top Tips For Database Seeds
Remember that seeds can call other seeds, so it’s
possible to categorise them
You can use seeds in production to insert settings into the
database
Keep your seeds as simple as possible

54. SUMMARY
And Finally…
A set of well maintained migrations and seeds will save
you time in the long run
It’s possible to share your database files between projects
using composer

55. jedatron
edcs
to.edcs.me/db-migration-hell