Migrations

Introducción

Las migraciones son como control de versiones para tu base de datos, lo que permite a tu equipo definir y compartir la definición del esquema de la base de datos de la aplicación. Si alguna vez has tenido que decirle a un compañero de equipo que añada manualmente una columna a su esquema de base de datos local después de incorporar tus cambios desde el control de versiones, has enfrentado el problema que las migraciones de base de datos resuelven. La Schema facade de Laravel proporciona soporte agnóstico a bases de datos para crear y manipular tablas en todos los sistemas de bases de datos admitidos por Laravel. Típicamente, las migraciones utilizarán esta fachada para crear y modificar tablas y columnas de base de datos.

Generating Migrations

Puedes usar el comando Artisan make:migration para generar una migración de base de datos. La nueva migración se colocará en tu directorio database/migrations. Cada nombre de archivo de migración contiene una marca de tiempo que permite a Laravel determinar el orden de las migraciones:

**php artisan make:migration create_flights_table**

Laravel utilizará el nombre de la migración para intentar adivinar el nombre de la tabla y si la migración creará o no una nueva tabla. Si Laravel puede determinar el nombre de la tabla a partir del nombre de la migración, Laravel rellenará automáticamente el archivo de migración generado con la tabla especificada. De lo contrario, puedes especificar la tabla en el archivo de migración manualmente. Si deseas especificar una ruta personalizada para la migración generada, puedes utilizar la opción --path al ejecutar el comando make:migration. La ruta dada debe ser relativa a la ruta base de tu aplicación.

ℹ️ Los stubs de migración se pueden personalizar utilizando la publicación de stubs.

Squashing Migrations

A medida que construyes tu aplicación, es posible que acumules más y más migraciones con el tiempo. Esto puede llevar a que tu directorio database/migrations se vuelva engorroso con potencialmente cientos de migraciones. Si lo deseas, puedes “compactar” tus migraciones en un solo archivo SQL. Para comenzar, ejecuta el comando schema:dump:

php artisan schema:dump
 
# Dump the current database schema and prune all existing migrations...
php artisan schema:dump --prune

Cuando ejecutes este comando, Laravel escribirá un archivo “schema” en el directorio database/schema de tu aplicación. El nombre del archivo de esquema corresponderá a la conexión de base de datos. Ahora, cuando intentes migrar tu base de datos y no se hayan ejecutado otras migraciones, Laravel primero ejecutará las sentencias SQL en el archivo de esquema de la conexión de base de datos que estás utilizando. Después de ejecutar las sentencias SQL del archivo de esquema, Laravel ejecutará cualquier migración restante que no formara parte del volcado del esquema.

Si las pruebas de tu aplicación utilizan una conexión de base de datos diferente a la que sueles usar durante el desarrollo local, debes asegurarte de haber volcado un archivo de esquema utilizando esa conexión de base de datos para que tus pruebas puedan construir tu base de datos. Es posible que desees hacer esto después de volcar la conexión de base de datos que sueles usar durante el desarrollo local:

php artisan schema:dump
php artisan schema:dump --database=testing --prune

Debes comprometer el archivo del esquema de tu base de datos al control de versiones para que otros desarrolladores nuevos en tu equipo puedan crear rápidamente la estructura de base de datos inicial de tu aplicación.

❗ La compactación de migraciones solo está disponible para las bases de datos MariaDB, MySQL, PostgreSQL y SQLite y utiliza el cliente de línea de comandos de la base de datos.

Migration Structure

Una clase de migración contiene dos métodos: up y down. El método up se utiliza para agregar nuevas tablas, columnas o índices a tu base de datos, mientras que el método down debe revertir las operaciones realizadas por el método up. Dentro de ambos métodos, puedes usar el constructor de esquema de Laravel para crear y modificar tablas de manera expresiva. Para aprender sobre todos los métodos disponibles en el constructor Schema, consulta su documentación. Por ejemplo, la siguiente migración crea una tabla flights:

<?php
 
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('flights', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('airline');
            $table->timestamps();
        });
    }
 
    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::drop('flights');
    }
};

Setting the Migration Connection

Si tu migración estará interactuando con una conexión a base de datos diferente de la conexión a base de datos predeterminada de tu aplicación, deberías establecer la propiedad $connection de tu migración:

/**
 * The database connection that should be used by the migration.
 *
 * @var string
 */
protected $connection = 'pgsql';
 
/**
 * Run the migrations.
 */
public function up(): void
{
    // ...
}

Running Migrations

Para ejecutar todas tus migraciones pendientes, ejecuta el comando Artisan migrate:

**php artisan migrate**

Si deseas ver qué migraciones se han ejecutado hasta ahora, puedes usar el comando Artisan migrate:status:

**php artisan migrate:status**

Si deseas ver las declaraciones SQL que se ejecutarán mediante las migraciones sin ejecutarlas realmente, puedes proporcionar la bandera --pretend al comando migrate:

**php artisan migrate --pretend**

Isolating Migration Execution

Si estás desplegando tu aplicación en múltiples servidores y ejecutando migraciones como parte de tu proceso de despliegue, es probable que no quieras que dos servidores intenten migrar la base de datos al mismo tiempo. Para evitar esto, puedes usar la opción isolated al invocar el comando migrate.

Cuando se proporciona la opción isolated, Laravel adquirirá un bloqueo atómico utilizando el driver de caché de tu aplicación antes de intentar ejecutar tus migraciones. Todos los otros intentos de ejecutar el comando migrate mientras se mantiene ese bloqueo no se ejecutarán; sin embargo, el comando todavía saldrá con un código de estado de salida exitoso:

**php artisan migrate --isolated**

❗ Para utilizar esta función, tu aplicación debe estar utilizando el driver de caché memcached, redis, dynamodb, database, file o array como el driver de caché predeterminado de tu aplicación. Además, todos los servidores deben estar comunicándose con el mismo servidor de caché central.

Forcing Migrations to Run in Production

Algunas operaciones de migración son destructivas, lo que significa que pueden hacer que pierdas datos. Para protegerte de ejecutar estos comandos en tu base de datos de producción, se te pedirá confirmación antes de que se ejecuten los comandos. Para forzar la ejecución de los comandos sin un aviso, usa el flag --force:

php artisan migrate --force

Rolling Back Migrations

Para deshacer la última operación de migración, puedes usar el comando Artisan rollback. Este comando deshace el último “lote” de migraciones, que puede incluir varios archivos de migración:

**php artisan migrate:rollback**

Puedes revertir un número limitado de migraciones proporcionando la opción step al comando rollback. Por ejemplo, el siguiente comando revertirá las últimas cinco migraciones:

**php artisan migrate:rollback --step=5**

Puedes revertir un “batch” específico de migraciones proporcionando la opción batch al comando rollback, donde la opción batch corresponde a un valor de lote dentro de la tabla migrations de la base de datos de tu aplicación. Por ejemplo, el siguiente comando revertirá todas las migraciones en el lote tres:

**php artisan migrate:rollback --batch=3**

Si deseas ver las declaraciones SQL que se ejecutarán mediante las migraciones sin realmente ejecutarlas, puedes proporcionar el flag --pretend al comando migrate:rollback:

**php artisan migrate:rollback --pretend**

El comando migrate:reset revertirá todas las migraciones de tu aplicación:

**php artisan migrate:reset**

Roll Back and Migrate Using a Single Command

El comando migrate:refresh revertirá todas tus migraciones y luego ejecutará el comando migrate. Este comando efectivamente vuelve a crear toda tu base de datos:

php artisan migrate:refresh
 
# Refresh the database and run all database seeds...
php artisan migrate:refresh --seed

Puedes deshacer y reiniciar un número limitado de migraciones proporcionando la opción step al comando refresh. Por ejemplo, el siguiente comando deshará y volverá a migrar las últimas cinco migraciones:

php artisan migrate:refresh --step=5

Drop All Tables and Migrate

El comando migrate:fresh eliminará todas las tablas de la base de datos y luego ejecutará el comando migrate:

php artisan migrate:fresh
 
php artisan migrate:fresh --seed

Por defecto, el comando migrate:fresh solo elimina tablas de la conexión de base de datos predeterminada. Sin embargo, puedes usar la opción --database para especificar la conexión de base de datos que se debe migrar. El nombre de la conexión de base de datos debe corresponder a una conexión definida en el archivo de configuración database de tu aplicación configuración:

php artisan migrate:fresh --database=admin

❗ El comando migrate:fresh eliminará todas las tablas de la base de datos sin importar su prefijo. Este comando debe usarse con precaución al desarrollar en una base de datos que se comparte con otras aplicaciones.

Tables

Creating Tables

Para crear una nueva tabla de base de datos, utiliza el método create en la fachada Schema. El método create acepta dos argumentos: el primero es el nombre de la tabla, mientras que el segundo es una función anónima que recibe un objeto Blueprint que se puede usar para definir la nueva tabla:

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email');
    $table->timestamps();
});

Al crear la tabla, puedes usar cualquiera de los métodos de columna del generador de esquemas para definir las columnas de la tabla.

Determining Table / Column Existence

Puedes determinar la existencia de una tabla, columna o índice utilizando los métodos hasTable, hasColumn y hasIndex:

if (Schema::hasTable('users')) {
    // The "users" table exists...
}
 
if (Schema::hasColumn('users', 'email')) {
    // The "users" table exists and has an "email" column...
}
 
if (Schema::hasIndex('users', ['email'], 'unique')) {
    // The "users" table exists and has a unique index on the "email" column...
}

Database Connection and Table Options

Si deseas realizar una operación de esquema en una conexión de base de datos que no sea la conexión predeterminada de tu aplicación, utiliza el método connection:

Schema::connection('sqlite')->create('users', function (Blueprint $table) {
    $table->id();
});

Además, se pueden usar algunas otras propiedades y métodos para definir otros aspectos de la creación de la tabla. La propiedad engine se puede utilizar para especificar el motor de almacenamiento de la tabla al utilizar MariaDB o MySQL:

Schema::create('users', function (Blueprint $table) {
    $table->engine('InnoDB');
 
    // ...
});

Las propiedades charset y collation se pueden utilizar para especificar el conjunto de caracteres y la intercalación para la tabla creada al usar MariaDB o MySQL:

Schema::create('users', function (Blueprint $table) {
    $table->engine('InnoDB');
 
    // ...
});

El método temporary se puede utilizar para indicar que la tabla debe ser “temporal”. Las tablas temporales solo son visibles para la sesión de base de datos de la conexión actual y se eliminan automáticamente cuando se cierra la conexión:

Schema::create('calculations', function (Blueprint $table) {
    $table->temporary();
 
    // ...
});

Si deseas añadir un “comentario” a una tabla de base de datos, puedes invocar el método comment en la instancia de la tabla. Los comentarios de tabla son actualmente solo soportados por MariaDB, MySQL y PostgreSQL:

Schema::create('calculations', function (Blueprint $table) {
    $table->comment('Business calculations');
 
    // ...
});

Updating Tables

El método table en la fachada Schema se puede usar para actualizar tablas existentes. Al igual que el método create, el método table acepta dos argumentos: el nombre de la tabla y una función anónima que recibe una instancia de Blueprint que puedes usar para añadir columnas o índices a la tabla:

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
Schema::table('users', function (Blueprint $table) {
    $table->integer('votes');
});

Renaming / Dropping Tables

Para renombrar una tabla de base de datos existente, utiliza el método rename:

use Illuminate\Support\Facades\Schema;
 
Schema::rename($from, $to);

Para eliminar una tabla existente, puedes usar los métodos drop o dropIfExists:

Schema::drop('users');
 
Schema::dropIfExists('users');

Renaming Tables With Foreign Keys

Antes de renombrar una tabla, debes verificar que cualquier restricción de clave externa en la tabla tenga un nombre explícito en tus archivos de migración en lugar de dejar que Laravel asigne un nombre basado en convención. De lo contrario, el nombre de la restricción de clave externa se referirá al antiguo nombre de la tabla.

Columns

Creating Columns

El método table en la fachada Schema se puede usar para actualizar tablas existentes. Al igual que el método create, el método table acepta dos argumentos: el nombre de la tabla y una función anónima que recibe una instancia de Illuminate\Database\Schema\Blueprint que puedes usar para agregar columnas a la tabla:

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
Schema::table('users', function (Blueprint $table) {
    $table->integer('votes');
});

Available Column Types

El esquema de la construcción de planos ofrece una variedad de métodos que corresponden a los diferentes tipos de columnas que puedes añadir a tus tablas de base de datos. Cada uno de los métodos disponibles se enumera en la tabla a continuación:

bigIncrements

bigInteger

binary

boolean

char

dateTimeTz

dateTime

date

decimal

double

enum

float

foreignId

foreignIdFor

foreignUlid

foreignUuid

geography

geometry

id

increments

integer

ipAddress

json

jsonb

longText

macAddress

mediumIncrements

mediumInteger

mediumText

morphs

nullableMorphs

nullableTimestamps

nullableUlidMorphs

nullableUuidMorphs

rememberToken

set

smallIncrements

smallInteger

softDeletesTz

softDeletes

string

text

timeTz

time

timestampTz

timestamp

timestampsTz

timestamps

tinyIncrements

tinyInteger

tinyText

unsignedBigInteger

unsignedInteger

unsignedMediumInteger

unsignedSmallInteger

unsignedTinyInteger

ulidMorphs

uuidMorphs

ulid

uuid

vector

year

Column Modifiers

Además de los tipos de columna listados anteriormente, hay varios “modificadores” de columna que puedes usar al agregar una columna a una tabla de base de datos. Por ejemplo, para hacer que la columna sea “nullable”, puedes usar el método nullable:

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
Schema::table('users', function (Blueprint $table) {
    $table->string('email')->nullable();
});

La siguiente tabla contiene todos los modificadores de columna disponibles. Esta lista no incluye modificadores de índice:

Modificador	Descripción
->after('column')	Coloca la columna “después” de otra columna (MariaDB / MySQL).
->autoIncrement()	Establece columnas INTEGER como auto-incrementales (clave primaria).
->charset('utf8mb4')	Especifica un conjunto de caracteres para la columna (MariaDB / MySQL).
->collation('utf8mb4_unicode_ci')	Especifica una colación para la columna.
->comment('my comment')	Añade un comentario a una columna (MariaDB / MySQL / PostgreSQL).
->default($value)	Especifica un valor “por defecto” para la columna.
->first()	Coloca la columna “primera” en la tabla (MariaDB / MySQL).
->from($integer)	Establece el valor inicial de un campo auto-incrementable (MariaDB / MySQL / PostgreSQL).
->invisible()	Hace que la columna sea “invisible” para consultas SELECT * (MariaDB / MySQL).
->nullable($value = true)	Permite que se inserten valores NULL en la columna.
->storedAs($expression)	Crea una columna generada almacenada (MariaDB / MySQL / PostgreSQL / SQLite).
->unsigned()	Establece columnas INTEGER como UNSIGNED (MariaDB / MySQL).
->useCurrent()	Establece columnas TIMESTAMP para usar CURRENT_TIMESTAMP como valor por defecto.
->useCurrentOnUpdate()	Establece columnas TIMESTAMP para usar CURRENT_TIMESTAMP cuando se actualiza un registro (MariaDB / MySQL).
->virtualAs($expression)	Crea una columna generada virtual (MariaDB / MySQL / SQLite).
->generatedAs($expression)	Crea una columna de identidad con opciones de secuencia especificadas (PostgreSQL).
->always()	Define la precedencia de los valores de secuencia sobre la entrada para una columna de identidad (PostgreSQL).

Default Expressions

El modificador default acepta un valor o una instancia de Illuminate\Database\Query\Expression. Usar una instancia de Expression evitará que Laravel envuelva el valor entre comillas y te permitirá usar funciones específicas de la base de datos. Una situación donde esto es especialmente útil es cuando necesitas asignar valores predeterminados a columnas JSON:

<?php
 
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Query\Expression;
use Illuminate\Database\Migrations\Migration;
 
return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('flights', function (Blueprint $table) {
            $table->id();
            $table->json('movies')->default(new Expression('(JSON_ARRAY())'));
            $table->timestamps();
        });
    }
};

❗ El soporte para expresiones por defecto depende de tu driver de base de datos, versión de base de datos y el tipo de campo. Por favor, consulta la documentación de tu base de datos.

Column Order

Al utilizar la base de datos MariaDB o MySQL, el método after puede usarse para añadir columnas después de una columna existente en el esquema:

$table->after('password', function (Blueprint $table) {
    $table->string('address_line1');
    $table->string('address_line2');
    $table->string('city');
});

Modifying Columns

El método change te permite modificar el tipo y los atributos de las columnas existentes. Por ejemplo, es posible que desees aumentar el tamaño de una columna string. Para ver el método change en acción, aumentemos el tamaño de la columna name de 25 a 50. Para lograr esto, simplemente definimos el nuevo estado de la columna y luego llamamos al método change:

Schema::table('users', function (Blueprint $table) {
    $table->string('name', 50)->change();
});

Al modificar una columna, debes incluir explícitamente todos los modificadores que deseas mantener en la definición de la columna; cualquier atributo que falte será eliminado. Por ejemplo, para retener los atributos unsigned, default y comment, debes llamar a cada modificador de forma explícita al cambiar la columna:

Schema::table('users', function (Blueprint $table) {
    $table->integer('votes')->unsigned()->default(1)->comment('my comment')->change();
});

El método change no cambia los índices de la columna. Por lo tanto, puedes usar modificadores de índice para agregar o eliminar explícitamente un índice al modificar la columna:

// Add an index...
$table->bigIncrements('id')->primary()->change();
 
// Drop an index...
$table->char('postal_code', 10)->unique(false)->change();

Renaming Columns

Para renombrar una columna, puedes usar el método renameColumn proporcionado por el constructor de esquemas:

Schema::table('users', function (Blueprint $table) {
    $table->renameColumn('from', 'to');
});

Dropping Columns

Para eliminar una columna, puedes usar el método dropColumn en el constructor de esquemas:

Schema::table('users', function (Blueprint $table) {
    $table->dropColumn('votes');
});

Puedes eliminar múltiples columnas de una tabla pasando un array de nombres de columna al método dropColumn:

Schema::table('users', function (Blueprint $table) {
    $table->dropColumn(['votes', 'avatar', 'location']);
});

Available Command Aliases

Laravel ofrece varios métodos convenientes relacionados con la eliminación de tipos comunes de columnas. Cada uno de estos métodos se describe en la tabla a continuación:

Comando	Descripción
$table->dropMorphs('morphable');	Eliminar las columnas morphable_id y morphable_type.
$table->dropRememberToken();	Eliminar la columna remember_token.
$table->dropSoftDeletes();	Eliminar la columna deleted_at.
$table->dropSoftDeletesTz();	Alias del método dropSoftDeletes().
$table->dropTimestamps();	Eliminar las columnas created_at y updated_at.
$table->dropTimestampsTz();	Alias del método dropTimestamps().

Indexes

Creating Indexes

El constructor de esquemas de Laravel admite varios tipos de índices. El siguiente ejemplo crea una nueva columna email y especifica que sus valores deben ser únicos. Para crear el índice, podemos encadenar el método unique a la definición de la columna:

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
Schema::table('users', function (Blueprint $table) {
    $table->string('email')->unique();
});

Alternativamente, puedes crear el índice después de definir la columna. Para hacerlo, debes llamar al método unique en el plano del generador de esquemas. Este método acepta el nombre de la columna que debe recibir un índice único:

$table->unique('email');

Puedes incluso pasar un array de columnas a un método de índice para crear un índice compuesto:

**$table->index(['account_id', 'created_at']);**

Al crear un índice, Laravel generará automáticamente un nombre de índice basado en la tabla, los nombres de las columnas y el tipo de índice, pero puedes pasar un segundo argumento al método para especificar el nombre del índice tú mismo:

**$table->index(['account_id', 'created_at']);**

Available Index Types

La clase blueprint del constructor de esquemas de Laravel proporciona métodos para crear cada tipo de índice soportado por Laravel. Cada método de índice acepta un segundo argumento opcional para especificar el nombre del índice. Si se omite, el nombre se derivará de los nombres de la tabla y la(s) columna(s) utilizadas para el índice, así como del tipo de índice. Cada uno de los métodos de índice disponibles se describe en la tabla a continuación:

Comando	Descripción
$table->primary('id');	Añade una clave primaria.
$table->primary(['id', 'parent_id']);	Añade claves compuestas.
$table->unique('email');	Añade un índice único.
$table->index('state');	Añade un índice.
$table->fullText('body');	Añade un índice de texto completo (MariaDB / MySQL / PostgreSQL).
$table->fullText('body')->language('english');	Añade un índice de texto completo del idioma especificado (PostgreSQL).
$table->spatialIndex('location');	Añade un índice espacial (excepto SQLite).

Renaming Indexes

Para renombrar un índice, puedes usar el método renameIndex proporcionado por el blueprint del constructor de esquema. Este método acepta el nombre actual del índice como su primer argumento y el nombre deseado como su segundo argumento:

**$table->renameIndex('from', 'to')**

Dropping Indexes

Para eliminar un índice, debes especificar el nombre del índice. Por defecto, Laravel asigna automáticamente un nombre de índice basado en el nombre de la tabla, el nombre de la columna indexada y el tipo de índice. Aquí hay algunos ejemplos:

Comando	Descripción
$table->dropPrimary('users_id_primary');	Eliminar una clave primaria de la tabla “users”.
$table->dropUnique('users_email_unique');	Eliminar un índice único de la tabla “users”.
$table->dropIndex('geo_state_index');	Eliminar un índice básico de la tabla “geo”.
$table->dropFullText('posts_body_fulltext');	Eliminar un índice de texto completo de la tabla “posts”.
$table->dropSpatialIndex('geo_location_spatialindex');	Eliminar un índice espacial de la tabla “geo” (excepto SQLite).

Si pasas un array de columnas a un método que elimina índices, el nombre del índice convencional se generará en base al nombre de la tabla, las columnas y el tipo de índice:

Schema::table('geo', function (Blueprint $table) {
    $table->dropIndex(['state']); // Drops index 'geo_state_index'
});

Foreign Key Constraints

Laravel también proporciona soporte para la creación de restricciones de clave foránea, que se utilizan para forzar la integridad referencial a nivel de base de datos. Por ejemplo, definamos una columna user_id en la tabla posts que haga referencia a la columna id en una tabla users:

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
Schema::table('posts', function (Blueprint $table) {
    $table->unsignedBigInteger('user_id');
 
    $table->foreign('user_id')->references('id')->on('users');
});

Dado que esta sintaxis es bastante verbosa, Laravel ofrece métodos adicionales y más concisos que utilizan convenciones para proporcionar una mejor experiencia al desarrollador. Al usar el método foreignId para crear tu columna, el ejemplo anterior se puede reescribir así:

Schema::table('posts', function (Blueprint $table) {
    $table->foreignId('user_id')->constrained();
});

El método foreignId crea una columna equivalente de UNSIGNED BIGINT, mientras que el método constrained utilizará convenciones para determinar la tabla y la columna que se están referenciando. Si el nombre de tu tabla no coincide con las convenciones de Laravel, puedes proporcionarlo manualmente al método constrained. Además, el nombre que se debe asignar al índice generado también se puede especificar:

Schema::table('posts', function (Blueprint $table) {
    $table->foreignId('user_id')->constrained(
        table: 'users', indexName: 'posts_user_id'
    );
});

También puedes especificar la acción deseada para las propiedades “on delete” y “on update” de la restricción:

$table->foreignId('user_id')
      ->constrained()
      ->onUpdate('cascade')
      ->onDelete('cascade');

También se ofrece una sintaxis alternativa y expresiva para estas acciones:

Método	Descripción
$table->cascadeOnUpdate();	Las actualizaciones deben ser en cascada.
$table->restrictOnUpdate();	Las actualizaciones deben ser restringidas.
$table->noActionOnUpdate();	Sin acción en las actualizaciones.
$table->cascadeOnDelete();	Las eliminaciones deben ser en cascada.
$table->restrictOnDelete();	Las eliminaciones deben ser restringidas.
$table->nullOnDelete();	Las eliminaciones deben establecer el valor de la clave foránea en null.

Cualquier modificador de columna adicional debe ser llamado antes del método constrained:

$table->foreignId('user_id')
      ->nullable()
      ->constrained();

Dropping Foreign Keys

Para eliminar una clave foránea, puedes usar el método dropForeign, pasando el nombre de la restricción de clave foránea que se va a eliminar como argumento. Las restricciones de clave foránea utilizan la misma convención de nombres que los índices. En otras palabras, el nombre de la restricción de clave foránea se basa en el nombre de la tabla y las columnas en la restricción, seguido de un sufijo “_foreign”:

$table->dropForeign('posts_user_id_foreign');

Alternativamente, puedes pasar un array que contenga el nombre de la columna que tiene la clave foránea al método dropForeign. El array se convertirá en un nombre de restricción de clave foránea utilizando las convenciones de nomenclatura de restricciones de Laravel:

$table->dropForeign(['user_id']);

Toggling Foreign Key Constraints

Puedes habilitar o deshabilitar las restricciones de claves foráneas dentro de tus migraciones utilizando los siguientes métodos:

Schema::enableForeignKeyConstraints();
 
Schema::disableForeignKeyConstraints();
 
Schema::withoutForeignKeyConstraints(function () {
    // Constraints disabled within this closure...
});

❗ SQLite desactiva las restricciones de claves foráneas por defecto. Al usar SQLite, asegúrate de habilitar el soporte de claves foráneas en tu configuración de base de datos antes de intentar crearlas en tus migraciones.

Events

Para mayor comodidad, cada operación de migración despachará un evento. Todos los siguientes eventos extienden la clase base Illuminate\Database\Events\MigrationEvent:

Clase	Descripción
Illuminate\Database\Events\MigrationsStarted	Un lote de migraciones está a punto de ser ejecutado.
Illuminate\Database\Events\MigrationsEnded	Un lote de migraciones ha terminado de ejecutarse.
Illuminate\Database\Events\MigrationStarted	Una sola migración está a punto de ser ejecutada.
Illuminate\Database\Events\MigrationEnded	Una sola migración ha terminado de ejecutarse.
Illuminate\Database\Events\NoPendingMigrations	Un comando de migración no encontró migraciones pendientes.
Illuminate\Database\Events\SchemaDumped	Se ha completado un volcado de esquema de base de datos.
Illuminate\Database\Events\SchemaLoaded	Se ha cargado un volcado de esquema de base de datos existente.