Database Schema Management in Laravel Using Migrations: An In-Depth Tutorial

Laravel migrations are a great way to manage database schema changes. They allow you to version-control the database structure and easily roll back or modify changes over time. In this guide, we will explore the process of creating, running, and rolling back migrations in Laravel step-by-step, along with a hands-on example.

Step 1: Setup Laravel Environment

Before starting with migrations, ensure that you have Laravel installed. You can do this via Composer:

composer create-project --prefer-dist laravel/laravel migration-demo

Then navigate into the project folder:

cd migration-demo

Step 2: Database Configuration

To configure the database, open the .env file in your Laravel project and update the database credentials:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=your_database_name
DB_USERNAME=your_username
DB_PASSWORD=your_password

After configuring your database, you can create a new database in your local environment if it doesn’t already exist.

Step 3: Creating a Migration

You can create a new migration using the artisan command. For example, to create a users table migration:

php artisan make:migration create_users_table

This command generates a migration file in the database/migrations directory. The filename will contain a timestamp and look something like 2024_09_13_123456_create_users_table.php.

Step 4: Defining the Migration Schema

Open the generated migration file. You will find two methods: up() (to define the table creation) and down() (to define how the table should be rolled back).

Example for creating a users table:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id(); // Primary key
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps(); // Created at & Updated at
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('users');
    }
}

In the up() method, we define the structure of the users table. The down() method defines how to remove the table in case of a rollback (i.e., dropping the table).

Step 5: Running the Migration

To run the migration and create the users table in your database, use the following command:

php artisan migrate

This command will execute all migrations that have not yet been run. You should see the following output:

Migrating: 2024_09_13_123456_create_users_table
Migrated:  2024_09_13_123456_create_users_table (0.45 seconds)

You can verify that the users table has been created in your database.

Step 6: Rolling Back Migrations

To roll back the most recent migration, use the following command:

php artisan migrate:rollback

This will remove the users table or any table defined in the most recent migration batch.

To roll back multiple migration steps, use:

php artisan migrate:rollback --step=2

This rolls back the last two batches of migrations.

Step 7: Modifying an Existing Table

If you want to modify an existing table (for example, adding a column), create a new migration:

php artisan make:migration add_phone_to_users_table --table=users

This creates a migration for modifying the users table. You can then define the changes:

public function up()
{
    Schema::table('users', function (Blueprint $table) {
        $table->string('phone')->nullable(); // Add phone column
    });
}

public function down()
{
    Schema::table('users', function (Blueprint $table) {
        $table->dropColumn('phone'); // Remove phone column
    });
}

Run the migration to apply the changes:

php artisan migrate

Step 8: Seeding the Database

Laravel also allows you to seed the database with dummy data. To create a seeder, use:

php artisan make:seeder UsersTableSeeder

In the seeder file located in database/seeders/UsersTableSeeder.php, you can define the data:

use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;

class UsersTableSeeder extends Seeder
{
    public function run()
    {
        DB::table('users')->insert([
            'name' => 'John Doe',
            'email' => '[e-mail]',
            'password' => Hash::make('password'),
        ]);
    }
}

Then run the seeder using:

php artisan db:seed --class=UsersTableSeeder

You can also seed the database during migration by calling the seeder in DatabaseSeeder.php.

Step 9: Running All Migrations and Seeders

To reset the database and run all migrations and seeders:

php artisan migrate:fresh --seed

This command will drop all tables, re-run all migrations, and seed the database.

Step 10: Migration Best Practices

• Version Control: Always commit migrations to version control (Git) along with your code.
• Small Migrations: Break large migrations into smaller ones to make rollback and debugging easier.
• Avoid Changing Existing Migrations: If you’ve already run a migration in production, create a new one to modify the database instead of changing the existing migration.

Hands-on Example Summary

1. Create a new Laravel project.
2. Configure the .env file for the database connection.
3. Create a migration for the users table.
4. Define the table schema in the up() method.
5. Run the migration with php artisan migrate.
6. Modify the users table by adding a phone column via another migration.
7. Roll back or re-run migrations as needed.
8. Seed the database with sample data.
9. Manage database state using migrations efficiently.

---

By following these steps, you can easily manage database schema changes in Laravel using migrations. Laravel migrations are an essential part of keeping the database structure version-controlled and synced across different environments like development, staging, and production.