Base de Données - Migrations - Laravel - Le Framework PHP Pour Les Artisans Du Web Doc Officiel de Laravel

27/03/2023 02:56 Base de données : Migrations - Laravel - Le framework PHP pour les artisans du web
VERS ION
9.x
Recherche
AVERTISSEMENT Vous parcourez la documentation d'une ancienne version de

Laravel. Envisagez de mettre à niveau votre projet vers Laravel 10.x .
Base de données : Migrations

# Introduction
# Génération de migrations
# Écraser les migrations
# Structure migratoire
# Exécution de migrations
# Restauration des migrations
# les tables
# Création de tableaux
# Mise à jour des tableaux
# Renommer / supprimer des tables
# Colonnes
# Création de colonnes
# Types de colonnes disponibles

https://laravel.com/docs/9.x/migrations#main-content 1/43
# Modificateurs de colonne
# Modification des colonnes
# Renommer les colonnes
# Suppression de colonnes
# Index
# Création d'index
# Renommer les index
# Suppression d'index
# Contraintes de clé étrangère
# Événements
# Introduction
Les migrations sont comme un contrôle de version pour votre base de données,
permettant à votre équipe de définir et de partager la définition du schéma de
base de données de l'application. Si vous avez déjà dû demander à un coéquipier
d'ajouter manuellement une colonne à son schéma de base de données local
après avoir extrait vos modifications du contrôle de code source, vous avez été
confronté au problème résolu par les migrations de base de données.
La Schema façade Laravel fournit une prise en charge indépendante de la base de

données pour créer et manipuler des tables sur tous les systèmes de base de
données pris en charge par Laravel. En règle générale, les migrations utilisent
cette façade pour créer et modifier des tables et des colonnes de base de
données.
# Génération de migrations
Vous pouvez utiliser la make:migration commande Artisan pour générer une
migration de base de données. La nouvelle migration sera placée dans votre
database/migrations répertoire. Chaque nom de fichier de migration contient un
horodatage qui permet à Laravel de déterminer l'ordre des migrations :
php artisan make:migration create_flights_table
Laravel utilisera le nom de la migration pour tenter de deviner le nom de la table et

si la migration créera ou non une nouvelle table. Si Laravel est capable de
déterminer le nom de la table à partir du nom de la migration, Laravel pré-
remplira le fichier de migration généré avec la table spécifiée. Sinon, vous pouvez
simplement spécifier manuellement la table dans le fichier de migration.
Si vous souhaitez spécifier un chemin personnalisé pour la migration générée, vous

pouvez utiliser l' --path option lors de l'exécution de la make:migration commande.
Le chemin donné doit être relatif au chemin de base de votre application.
Les talons de migration peuvent être personnalisés à l'aide de la publication

de talons .
# Écraser les migrations

Au fur et à mesure que vous créez votre application, vous pouvez accumuler de
plus en plus de migrations au fil du temps. Cela peut conduire à ce que votre
database/migrations répertoire soit gonflé avec potentiellement des centaines de
migrations. Si vous le souhaitez, vous pouvez "écraser" vos migrations dans un seul
fichier SQL. Pour commencer, exécutez la schema:dump commande :
php artisan schema:dump
# Dump the current database schema and prune all existing migrations...
php artisan schema:dump --prune
Lorsque vous exécutez cette commande, Laravel écrira un fichier "schéma" dans
database/schema le répertoire de votre application. Le nom du fichier de schéma
correspondra à la connexion à la base de données. Maintenant, lorsque vous

essayez de migrer votre base de données et qu'aucune autre migration n'a été
exécutée, Laravel exécutera d'abord les instructions SQL du fichier de schéma de
la connexion à la base de données que vous utilisez. Après avoir exécuté les
instructions du fichier de schéma, Laravel exécutera toutes les migrations
restantes qui ne faisaient pas partie du vidage du schéma.
Si les tests de votre application utilisent une connexion à la base de données

différente de celle que vous utilisez généralement lors du développement local,
vous devez vous assurer d'avoir vidé un fichier de schéma à l'aide de cette
connexion à la base de données afin que vos tests puissent créer votre base de
données. Vous souhaiterez peut-être le faire après avoir vidé la connexion à la
base de données que vous utilisez généralement lors du développement local :
php artisan schema:dump

php artisan schema:dump --database=testing --prune
Vous devez valider votre fichier de schéma de base de données dans le contrôle de
code source afin que d'autres nouveaux développeurs de votre équipe puissent
créer rapidement la structure de base de données initiale de votre application.
L'écrasement de la migration n'est disponible que pour les bases de données

MySQL, PostgreSQL et SQLite et utilise le client de ligne de commande de la
base de données. Les vidages de schéma peuvent ne pas être restaurés dans
les bases de données SQLite en mémoire.
# Structure migratoire
Une classe de migration contient deux méthodes : up et down . La up méthode est

utilisée pour ajouter de nouvelles tables, colonnes ou index à votre base de
données, tandis que la down méthode doit inverser les opérations effectuées par la
up méthode.
Dans ces deux méthodes, vous pouvez utiliser le générateur de schémas Laravel
pour créer et modifier des tables de manière expressive. Pour en savoir plus sur
toutes les méthodes disponibles sur le Schema constructeur, consultez sa
documentation . Par exemple, la migration suivante crée une flights table :
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration

{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('flights', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->string('airline');
$table->timestamps();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::drop('flights');
}
};
# Définition de la connexion de migration
Si votre migration interagit avec une connexion à la base de données autre que la
connexion à la base de données par défaut de votre application, vous devez
définir la $connection propriété de votre migration :
/**
* The database connection that should be used by the migration.
*
* @var string
*/
protected $connection = 'pgsql';
/**
*
* @return void
*/
{
//
}
# Exécution de migrations
Pour exécuter toutes vos migrations en attente, exécutez la migrate commande
Artisan :
php artisan migrate
Si vous souhaitez voir quelles migrations ont été exécutées jusqu'à présent, vous
pouvez utiliser la migrate:status commande Artisan :
php artisan migrate:status
Si vous souhaitez voir les instructions SQL qui seront exécutées par les migrations
sans les exécuter réellement, vous pouvez fournir l' --pretend indicateur à la migrate
commande :
php artisan migrate --pretend
Isoler l'exécution de la migration
Si vous déployez votre application sur plusieurs serveurs et exécutez des migrations
dans le cadre de votre processus de déploiement, vous ne souhaitez
probablement pas que deux serveurs tentent de migrer la base de données en
même temps. Pour éviter cela, vous pouvez utiliser l' isolated option lors de l'appel
de la migrate commande.
Lorsque l' isolated option est fournie, Laravel acquiert un verrou atomique à l'aide
du pilote de cache de votre application avant de tenter d'exécuter vos migrations.
Toutes les autres tentatives d'exécution de la migrate commande pendant que ce
verrou est maintenu ne s'exécuteront pas ; cependant, la commande se terminera
toujours avec un code d'état de sortie réussie :
php artisan migrate --isolated
Pour utiliser cette fonctionnalité , votre application doit utiliser le pilote de

cache memcached , redis , , , ou comme pilote de cache par défaut de votre
application. De plus, tous les serveurs doivent communiquer avec le même
serveur de cache central. dynamodb database file array
# Forcer les migrations à s'exécuter en production
Certaines opérations de migration sont destructives, ce qui signifie qu'elles

peuvent vous faire perdre des données. Afin de vous empêcher d'exécuter ces
commandes sur votre base de données de production, vous serez invité à
confirmer avant l'exécution des commandes. Pour forcer les commandes à
s'exécuter sans invite, utilisez l' --force indicateur :
php artisan migrate --force
# Restauration des migrations

Pour annuler la dernière opération de migration, vous pouvez utiliser la rollback
commande Artisan. Cette commande annule le dernier "lot" de migrations, qui
peut inclure plusieurs fichiers de migration :
php artisan migrate:rollback
Vous pouvez annuler un nombre limité de migrations en fournissant l' step option à
la rollback commande. Par exemple, la commande suivante annulera les cinq
dernières migrations :
php artisan migrate:rollback --step=5
La migrate:reset commande annulera toutes les migrations de votre application :
php artisan migrate:reset
# Restauration et migration à l'aide d'une seule commande
La migrate:refresh commande annulera toutes vos migrations, puis exécutera la

migrate commande. Cette commande recrée efficacement l'intégralité de votre
base de données :
php artisan migrate:refresh
# Refresh the database and run all database seeds...

php artisan migrate:refresh --seed
Vous pouvez annuler et migrer à nouveau un nombre limité de migrations en

fournissant l' step option à la refresh commande. Par exemple, la commande
suivante annulera et re-migrera les cinq dernières migrations :
php artisan migrate:refresh --step=5
# Supprimer toutes les tables et migrer
La migrate:fresh commande supprimera toutes les tables de la base de données,

puis exécutera la migrate commande :
php artisan migrate:fresh
php artisan migrate:fresh --seed
La migrate:fresh commande supprimera toutes les tables de la base de

données, quel que soit leur préfixe. Cette commande doit être utilisée avec
prudence lors du développement sur une base de données partagée avec
d'autres applications.
# les tables
# Création de tableaux
Pour créer une nouvelle table de base de données, utilisez la create méthode sur la
Schema façade. La create méthode accepte deux arguments : le premier est le nom
de la table, tandis que le second est une fermeture qui reçoit un Blueprint objet
pouvant être utilisé pour définir la nouvelle table :
Schema::create('users', function (Blueprint $table) {

$table->id();
$table->string('name');
$table->string('email');
});
Lors de la création de la table, vous pouvez utiliser n'importe quelle méthode de

colonne du générateur de schéma pour définir les colonnes de la table.
# Vérification de l'existence d'une table/colonne
Vous pouvez vérifier l'existence d'une table ou d'une colonne en utilisant les
méthodes hasTable et hasColumn :
if (Schema::hasTable('users')) {
// The "users" table exists...
}
if (Schema::hasColumn('users', 'email')) {
// The "users" table exists and has an "email" column...
}
# Connexion à la base de données et options de table
Si vous souhaitez effectuer une opération de schéma sur une connexion à la base
de données qui n'est pas la connexion par défaut de votre application, utilisez la
connection méthode :
Schema::connection('sqlite')->create('users', function (Blueprint $table) {
$table->id();
});
De plus, quelques autres propriétés et méthodes peuvent être utilisées pour définir
d'autres aspects de la création de la table. La engine propriété peut être utilisée
pour spécifier le moteur de stockage de la table lors de l'utilisation de MySQL :

$table->engine = 'InnoDB';
// ...
});
Les propriétés charset et collation peuvent être utilisées pour spécifier le jeu de
caractères et le classement de la table créée lors de l'utilisation de MySQL :

$table->charset = 'utf8mb4';
$table->collation = 'utf8mb4_unicode_ci';
// ...
});
La temporary méthode peut être utilisée pour indiquer que la table doit être
"temporaire". Les tables temporaires ne sont visibles que pour la session de base
de données de la connexion en cours et sont supprimées automatiquement
lorsque la connexion est fermée :
Schema::create('calculations', function (Blueprint $table) {

$table->temporary();
// ...
});
Si vous souhaitez ajouter un "commentaire" à une table de base de données, vous

pouvez invoquer la comment méthode sur l'instance de table. Les commentaires de
table ne sont actuellement pris en charge que par MySQL et Postgres :
Schema::create('calculations', function (Blueprint $table) {

$table->comment('Business calculations');
// ...
});
# Mise à jour des tableaux

La table méthode sur la Schema façade peut être utilisée pour mettre à jour des
tables existantes. Comme la create méthode, la table méthode accepte deux
arguments : le nom de la table et une fermeture qui reçoit une Blueprint instance
que vous pouvez utiliser pour ajouter des colonnes ou des index à la table :
Schema::table('users', function (Blueprint $table) {

$table->integer('votes');
});
# Renommer / supprimer des tables

Pour renommer une table de base de données existante, utilisez la rename
méthode :
Schema::rename($from, $to);
Pour supprimer une table existante, vous pouvez utiliser les méthodes drop ou
dropIfExists :
Schema::drop('users');
Schema::dropIfExists('users');
# Renommer des tables avec des clés étrangères
Avant de renommer une table, vous devez vérifier que toutes les contraintes de clé
étrangère sur la table ont un nom explicite dans vos fichiers de migration au lieu
de laisser Laravel attribuer un nom basé sur une convention. Sinon, le nom de la
contrainte de clé étrangère fera référence à l'ancien nom de table.
# Colonnes
# Création de colonnes
La table méthode sur la Schema façade peut être utilisée pour mettre à jour des
tables existantes. Comme la create méthode, la table méthode accepte deux
arguments : le nom de la table et une fermeture qui reçoit une
Illuminate\Database\Schema\Blueprint instance que vous pouvez utiliser pour ajouter
des colonnes à la table :

});
# Types de colonnes disponibles

Le plan directeur du générateur de schéma offre une variété de méthodes qui
correspondent aux différents types de colonnes que vous pouvez ajouter à vos
tables de base de données. Chacune des méthodes disponibles est répertoriée
dans le tableau ci-dessous :
bigIncrements booléen dateHeure

grandEntier carboniser date
binaire dateHeureTz décimal
double mediumText temps

énumération morphes horodatageTz
flotter multiLineString horodatage
identifiant étranger multiPoint horodatagesTz
idétrangerpour multipolygone horodatages
étrangerUlid nullableMorphs minuscules incréments
Uuid étranger nullableTimestamps minusculeEntier
géométrieCollection nullableUlidMorphs minusculeTexte
géométrie nullableUuidMorphs unsignedBigInteger
identifiant indiquer unsignedDecimal
incréments polygone Entier non signé
entier RememberToken unsignedMediumInteger
adresse IP ensemble unsignedSmallInteger
json petits incréments unsignedTinyInteger
jsonb petitEntier ulidMorphs
lineString softSupprimeTz uuidMorphs
longText softDeletes ulid
Adresse Mac chaîne uuid
Incréments moyens texte année
moyenEntier tempsTz
# bigIncrements()
La bigIncrements méthode crée une UNSIGNED BIGINT colonne équivalente auto-

incrémentée (clé primaire) :
$table->bigIncrements('id');
# bigInteger()
La bigInteger méthode crée une BIGINT colonne équivalente :
$table->bigInteger('votes');
# binary()
La binary méthode crée une BLOB colonne équivalente :
$table->binary('photo');
# boolean()
La boolean méthode crée une BOOLEAN colonne équivalente :
$table->boolean('confirmed');
# char()
La char méthode crée une CHAR colonne équivalente d'une longueur donnée :
$table->char('name', 100);
# dateTimeTz()
La dateTimeTz méthode crée une DATETIME colonne équivalente (avec fuseau

horaire) avec une précision facultative (chiffres totaux) :
$table->dateTimeTz('created_at', $precision = 0);
# dateTime()
La dateTime méthode crée une DATETIME colonne équivalente avec une précision
facultative (nombre total de chiffres) :
$table->dateTime('created_at', $precision = 0);
# date()
La date méthode crée une DATE colonne équivalente :
$table->date('created_at');
# decimal()
La decimal méthode crée une DECIMAL colonne équivalente avec la précision

donnée (chiffres totaux) et l'échelle (chiffres décimaux) :
$table->decimal('amount', $precision = 8, $scale = 2);
# double()
La double méthode crée une DOUBLE colonne équivalente avec la précision donnée
(chiffres totaux) et l'échelle (chiffres décimaux) :
$table->double('amount', 8, 2);
# enum()
La enum méthode crée une ENUM colonne équivalente avec les valeurs valides
indiquées :
$table->enum('difficulty', ['easy', 'hard']);
# float()
La float méthode crée une FLOAT colonne équivalente avec la précision donnée
(chiffres totaux) et l'échelle (chiffres décimaux) :
$table->float('amount', 8, 2);
# foreignId()
La foreignId méthode crée une UNSIGNED BIGINT colonne équivalente :
$table->foreignId('user_id');
# foreignIdFor()
La foreignIdFor méthode ajoute une {column}_id UNSIGNED BIGINT colonne

équivalente pour une classe de modèle donnée :
$table->foreignIdFor(User::class);
# foreignUlid()
La foreignUlid méthode crée une ULID colonne équivalente :
$table->foreignUlid('user_id');
# foreignUuid()
La foreignUuid méthode crée une UUID colonne équivalente :
$table->foreignUuid('user_id');
# geometryCollection()
La geometryCollection méthode crée une GEOMETRYCOLLECTION colonne équivalente :
$table->geometryCollection('positions');
# geometry()
La geometry méthode crée une GEOMETRY colonne équivalente :
$table->geometry('positions');
# id()
La id méthode est un alias de la bigIncrements méthode. Par défaut, la méthode

créera une id colonne ; cependant, vous pouvez passer un nom de colonne si vous
souhaitez attribuer un nom différent à la colonne :
$table->id();
# increments()
La increments méthode crée une UNSIGNED INTEGER colonne équivalente auto-

incrémentée en tant que clé primaire :
$table->increments('id');
# integer()
La integer méthode crée une INTEGER colonne équivalente :
# ipAddress()
La ipAddress méthode crée une VARCHAR colonne équivalente :
$table->ipAddress('visitor');
# json()
La json méthode crée une JSON colonne équivalente :
$table->json('options');
# jsonb()
La jsonb méthode crée une JSONB colonne équivalente :
$table->jsonb('options');
# lineString()
La lineString méthode crée une LINESTRING colonne équivalente :
$table->lineString('positions');
# longText()
La longText méthode crée une LONGTEXT colonne équivalente :
$table->longText('description');
# macAddress()
La macAddress méthode crée une colonne destinée à contenir une adresse MAC.
Certains systèmes de base de données, tels que PostgreSQL, ont un type de
colonne dédié pour ce type de données. D'autres systèmes de base de données
utiliseront une colonne équivalente à une chaîne :
$table->macAddress('device');
# mediumIncrements()
La mediumIncrements méthode crée une UNSIGNED MEDIUMINT colonne équivalente

auto-incrémentée en tant que clé primaire :
$table->mediumIncrements('id');
# mediumInteger()
La mediumInteger méthode crée une MEDIUMINT colonne équivalente :
$table->mediumInteger('votes');
# mediumText()
La mediumText méthode crée une MEDIUMTEXT colonne équivalente :
$table->mediumText('description');
# morphs()
La morphs méthode est une méthode pratique qui ajoute une {column}_id
UNSIGNED BIGINT colonne équivalente et une {column}_type VARCHAR colonne
équivalente.
Cette méthode est destinée à être utilisée lors de la définition des colonnes
nécessaires à une relation Eloquent polymorphe . Dans l'exemple suivant, les
colonnes taggable_id et taggable_type seraient créées :
$table->morphs('taggable');
# multiLineString()
La multiLineString méthode crée une MULTILINESTRING colonne équivalente :
$table->multiLineString('positions');
# multiPoint()
La multiPoint méthode crée une MULTIPOINT colonne équivalente :
$table->multiPoint('positions');
# multiPolygon()
La multiPolygon méthode crée une MULTIPOLYGON colonne équivalente :
$table->multiPolygon('positions');
# nullableTimestamps()
La nullableTimestamps méthode est un alias de la méthode timestamps :
$table->nullableTimestamps(0);
# nullableMorphs()
La méthode est similaire à la méthode des morphes ; cependant, les colonnes

créées seront "nullables":
$table->nullableMorphs('taggable');
# nullableUlidMorphs()
La méthode est similaire à la méthode ulidMorphs ; cependant, les colonnes

$table->nullableUlidMorphs('taggable');
# nullableUuidMorphs()
La méthode est similaire à la méthode uuidMorphs ; cependant, les colonnes

$table->nullableUuidMorphs('taggable');
# point()
La point méthode crée une POINT colonne équivalente :
$table->point('position');
# polygon()
La polygon méthode crée une POLYGON colonne équivalente :
$table->polygon('position');
# rememberToken()
La rememberToken méthode crée une colonne équivalente nullable VARCHAR(100)

destinée à stocker le jeton d'authentification "se souvenir de moi" actuel :
$table->rememberToken();
# set()
La set méthode crée une SET colonne équivalente avec la liste donnée de valeurs
valides :
$table->set('flavors', ['strawberry', 'vanilla']);
# smallIncrements()
La smallIncrements méthode crée une UNSIGNED SMALLINT colonne équivalente auto-

$table->smallIncrements('id');
# smallInteger()
La smallInteger méthode crée une SMALLINT colonne équivalente :
$table->smallInteger('votes');
# softDeletesTz()
La softDeletesTz méthode ajoute une deleted_at TIMESTAMP colonne équivalente

nullable (avec fuseau horaire) avec une précision facultative (chiffres totaux).
Cette colonne est destinée à stocker l' deleted_at horodatage nécessaire à la
fonctionnalité "soft delete" d'Eloquent :
$table->softDeletesTz($column = 'deleted_at', $precision = 0);
# softDeletes()
La softDeletes méthode ajoute une deleted_at TIMESTAMP colonne équivalente

nullable avec une précision facultative (chiffres totaux). Cette colonne est destinée
à stocker l' deleted_at horodatage nécessaire à la fonctionnalité "soft delete"
d'Eloquent :
$table->softDeletes($column = 'deleted_at', $precision = 0);
# string()
La string méthode crée une VARCHAR colonne équivalente de la longueur donnée :
$table->string('name', 100);
# text()
La text méthode crée une TEXT colonne équivalente :
$table->text('description');
# timeTz()
La timeTz méthode crée une TIME colonne équivalente (avec fuseau horaire) avec
une précision facultative (chiffres totaux) :
$table->timeTz('sunrise', $precision = 0);
# time()
La time méthode crée une TIME colonne équivalente avec une précision facultative
(nombre total de chiffres) :
$table->time('sunrise', $precision = 0);
# timestampTz()
La timestampTz méthode crée une TIMESTAMP colonne équivalente (avec fuseau

horaire) avec une précision facultative (chiffres totaux) :
$table->timestampTz('added_at', $precision = 0);
# timestamp()
La timestamp méthode crée une TIMESTAMP colonne équivalente avec une précision
facultative (nombre total de chiffres) :
$table->timestamp('added_at', $precision = 0);
# timestampsTz()
La timestampsTz méthode crée created_at et updated_at TIMESTAMP (avec fuseau

horaire) des colonnes équivalentes avec une précision facultative (chiffres totaux) :
$table->timestampsTz($precision = 0);
# timestamps()
La timestamps méthode crée created_at des updated_at TIMESTAMP colonnes

équivalentes avec une précision facultative (chiffres totaux) :
$table->timestamps($precision = 0);
# tinyIncrements()
La tinyIncrements méthode crée une UNSIGNED TINYINT colonne équivalente auto-

$table->tinyIncrements('id');
# tinyInteger()
La tinyInteger méthode crée une TINYINT colonne équivalente :
$table->tinyInteger('votes');
# tinyText()
La tinyText méthode crée une TINYTEXT colonne équivalente :
$table->tinyText('notes');
# unsignedBigInteger()
La unsignedBigInteger méthode crée une UNSIGNED BIGINT colonne équivalente :
$table->unsignedBigInteger('votes');
# unsignedDecimal()
La unsignedDecimal méthode crée une UNSIGNED DECIMAL colonne équivalente avec

une précision facultative (chiffres totaux) et une échelle (chiffres décimaux) :
$table->unsignedDecimal('amount', $precision = 8, $scale = 2);
# unsignedInteger()
La unsignedInteger méthode crée une UNSIGNED INTEGER colonne équivalente :
$table->unsignedInteger('votes');
# unsignedMediumInteger()
La unsignedMediumInteger méthode crée une UNSIGNED MEDIUMINT colonne

équivalente :
$table->unsignedMediumInteger('votes');
# unsignedSmallInteger()
La unsignedSmallInteger méthode crée une UNSIGNED SMALLINT colonne équivalente :
$table->unsignedSmallInteger('votes');
# unsignedTinyInteger()
La unsignedTinyInteger méthode crée une UNSIGNED TINYINT colonne équivalente :
$table->unsignedTinyInteger('votes');
# ulidMorphs()
La ulidMorphs méthode est une méthode pratique qui ajoute une {column}_id
CHAR(26) colonne équivalente et une {column}_type VARCHAR colonne équivalente.
nécessaires pour une relation Eloquent polymorphe qui utilise des identifiants
ULID. Dans l'exemple suivant, les colonnes taggable_id et taggable_type seraient

créées :
$table->ulidMorphs('taggable');
# uuidMorphs()
La uuidMorphs méthode est une méthode pratique qui ajoute une {column}_id
CHAR(36) colonne équivalente et une {column}_type VARCHAR colonne équivalente.
nécessaires à une relation Eloquent polymorphe qui utilise des identifiants UUID.
Dans l'exemple suivant, les colonnes taggable_id et taggable_type seraient créées :
$table->uuidMorphs('taggable');
# ulid()
La ulid méthode crée une ULID colonne équivalente :
$table->ulid('id');
# uuid()
La uuid méthode crée une UUID colonne équivalente :
$table->uuid('id');
# year()
La year méthode crée une YEAR colonne équivalente :
$table->year('birth_year');
# Modificateurs de colonne
En plus des types de colonne répertoriés ci-dessus, il existe plusieurs
"modificateurs" de colonne que vous pouvez utiliser lors de l'ajout d'une colonne à
une table de base de données. Par exemple, pour rendre la colonne "nullable",
vous pouvez utiliser la nullable méthode :

$table->string('email')->nullable();
});
Le tableau suivant contient tous les modificateurs de colonne disponibles. Cette

liste n'inclut pas les modificateurs d'index :
Modificateur Description
->after('column') Placez la colonne "après" une autre colonne (MySQL).
Définissez les colonnes INTEGER comme auto-

->autoIncrement()
incrémentées (clé primaire).
Spécifiez un jeu de caractères pour la colonne

->charset('utf8mb4')
(MySQL).
Spécifiez un classement pour la colonne

->collation('utf8mb4_unicode_ci')
(MySQL/PostgreSQL/SQL Server).
Ajouter un commentaire à une colonne

->comment('my comment')
(MySQL/PostgreSQL).
->default($value) Spécifiez une valeur "par défaut" pour la colonne.
->first() Placez la colonne "première" dans la table (MySQL).
Définissez la valeur de départ d'un champ auto-

->from($integer)
incrémenté (MySQL / PostgreSQL).
Modificateur Description
Rendre la colonne "invisible" aux SELECT * requêtes
->invisible()
(MySQL).
->nullable($value = true) Autoriser l'insertion de valeurs NULL dans la colonne.
Créez une colonne générée stockée (MySQL /

->storedAs($expression)
PostgreSQL).
Définissez les colonnes INTEGER sur UNSIGNED

->unsigned()
(MySQL).
Définissez les colonnes TIMESTAMP pour utiliser

->useCurrent()
CURRENT_TIMESTAMP comme valeur par défaut.
Définissez les colonnes TIMESTAMP pour utiliser

->useCurrentOnUpdate() CURRENT_TIMESTAMP lorsqu'un enregistrement est
mis à jour.
->virtualAs($expression) Créez une colonne générée virtuelle (MySQL).
Créez une colonne d'identité avec les options de

->generatedAs($expression)
séquence spécifiées (PostgreSQL).
Définit la priorité des valeurs de séquence sur l'entrée

->always()
pour une colonne d'identité (PostgreSQL).
Définissez le type de colonne spatiale sur geometry -

->isGeometry()
le type par défaut est geography (PostgreSQL).
# Expressions par défaut
Le default modificateur accepte une valeur ou une

Illuminate\Database\Query\Expression instance. L'utilisation d'une Expression
instance empêchera Laravel d'envelopper la valeur entre guillemets et vous
permettra d'utiliser des fonctions spécifiques à la base de données. Une situation
où cela est particulièrement utile est lorsque vous devez attribuer des valeurs par
défaut aux colonnes JSON :
<?php
use Illuminate\Database\Query\Expression;
use Illuminate\Database\Migrations\Migration;
return new class extends Migration

{
/**
*
* @return void
*/
{
Schema::create('flights', function (Blueprint $table) {
$table->id();
$table->json('movies')->default(new Expression('(JSON_ARRAY())'));
});
}
};
La prise en charge des expressions par défaut dépend de votre pilote de base
de données, de la version de la base de données et du type de champ. Veuillez
vous référer à la documentation de votre base de données. De plus, il n'est pas
possible de combiner default des expressions brutes (en utilisant DB::raw ) avec
des changements de colonne via la change méthode.
# Ordre des colonnes
Lors de l'utilisation de la base de données MySQL, la after méthode peut être

utilisée pour ajouter des colonnes après une colonne existante dans le schéma :
$table->after('password', function ($table) {

$table->string('address_line1');
$table->string('address_line2');
$table->string('city');
});
# Modification des colonnes

# Conditions préalables
Avant de modifier une colonne, vous devez installer le doctrine/dbal package à

l'aide du gestionnaire de packages Composer. La bibliothèque Doctrine DBAL est
utilisée pour déterminer l'état actuel de la colonne et pour créer les requêtes SQL
nécessaires pour apporter les modifications demandées à votre colonne :
composer require doctrine/dbal
Si vous envisagez de modifier les colonnes créées à l'aide de la timestamp méthode,

vous devez également ajouter la configuration suivante au config/database.php
fichier de configuration de votre application :
use Illuminate\Database\DBAL\TimestampType;
'dbal' => [
'types' => [
'timestamp' => TimestampType::class,
],
],
Si votre application utilise Microsoft SQL Server, assurez-vous d'avoir installé

doctrine/dbal:^3.0 .
# Mise à jour des attributs de colonne
La change méthode permet de modifier le type et les attributs des colonnes

existantes. Par exemple, vous pouvez augmenter la taille d'une string colonne.
Pour voir la change méthode en action, augmentons la taille de la name colonne de
25 à 50. Pour ce faire, nous définissons simplement le nouvel état de la colonne
puis appelons la change méthode :

$table->string('name', 50)->change();
});
Nous pourrions également modifier une colonne pour qu'elle soit nullable :

$table->string('name', 50)->nullable()->change();
});
Les types de colonnes suivants peuvent être modifiés : bigInteger , binary ,

boolean , char , date , dateTime , dateTimeTz , decimal , double , integer , json ,
longText , mediumText , smallInteger , string , text , time , tinyText ,
unsignedBigInteger , , unsignedInteger , unsignedSmallInteger et uuid . Pour

modifier un timestamp type de colonne, un type Doctrine doit être enregistré .
# Renommer les colonnes

Pour renommer une colonne, vous pouvez utiliser la renameColumn méthode fournie
par le constructeur de schéma :
$table->renameColumn('from', 'to');
});
# Renommer des colonnes sur des bases de données héritées
Si vous exécutez une installation de base de données antérieure à l'une des

versions suivantes, vous devez vous assurer que vous avez installé la doctrine/dbal
bibliothèque via le gestionnaire de packages Composer avant de renommer une
colonne :
MySQL < 8.0.3
MariaDB < 10.5.2
SQLite < 3.25.0
# Dropping Columns
To drop a column, you may use the dropColumn method on the schema builder:

$table->dropColumn('votes');
});
You may drop multiple columns from a table by passing an array of column names
to the dropColumn method:

$table->dropColumn(['votes', 'avatar', 'location']);
});
# Dropping Columns On Legacy Databases
If you are running a version of SQLite prior to 3.35.0 , you must install the
doctrine/dbal package via the Composer package manager before the dropColumn
method may be used. Dropping or modifying multiple columns within a single
migration while using this package is not supported.
# Available Command Aliases
Laravel provides several convenient methods related to dropping common types

of columns. Each of these methods is described in the table below:
Command Description
Drop the morphable_id and morphable_type
$table->dropMorphs('morphable');
columns.
$table->dropRememberToken(); Drop the remember_token column.
$table->dropSoftDeletes(); Drop the deleted_at column.
$table->dropSoftDeletesTz(); Alias of dropSoftDeletes() method.
$table->dropTimestamps(); Drop the created_at and updated_at columns.
$table->dropTimestampsTz(); Alias of dropTimestamps() method.
# Indexes
# Creating Indexes
The Laravel schema builder supports several types of indexes. The following
example creates a new email column and specifies that its values should be
unique. To create the index, we can chain the unique method onto the column
definition:

$table->string('email')->unique();
});
Alternatively, you may create the index after defining the column. To do so, you
should call the unique method on the schema builder blueprint. This method
accepts the name of the column that should receive a unique index:
$table->unique('email');
You may even pass an array of columns to an index method to create a compound
(or composite) index:
$table->index(['account_id', 'created_at']);
When creating an index, Laravel will automatically generate an index name based
on the table, column names, and the index type, but you may pass a second
argument to the method to specify the index name yourself:
$table->unique('email', 'unique_email');
# Available Index Types
Laravel's schema builder blueprint class provides methods for creating each type
of index supported by Laravel. Each index method accepts an optional second
argument to specify the name of the index. If omitted, the name will be derived
from the names of the table and column(s) used for the index, as well as the index
type. Each of the available index methods is described in the table below:
Command Description
$table->primary('id'); Adds a primary key.
$table->primary(['id', 'parent_id']); Adds composite keys.
$table->unique('email'); Adds a unique index.
$table->index('state'); Adds an index.
Adds a full text index

$table->fullText('body');
(MySQL/PostgreSQL).
Adds a full text index of the specified

$table->fullText('body')->language('english');
language (PostgreSQL).
Command Description
$table->spatialIndex('location'); Adds a spatial index (except SQLite).
# Index Lengths & MySQL / MariaDB
By default, Laravel uses the utf8mb4 character set. If you are running a version of
MySQL older than the 5.7.7 release or MariaDB older than the 10.2.2 release, you
may need to manually configure the default string length generated by migrations
in order for MySQL to create indexes for them. You may configure the default string
length by calling the Schema::defaultStringLength method within the boot method
of your App\Providers\AppServiceProvider class:
/**
* Bootstrap any application services.
*
* @return void
*/
public function boot()
{
Schema::defaultStringLength(191);
}
Alternatively, you may enable the innodb_large_prefix option for your database.
Refer to your database's documentation for instructions on how to properly enable
this option.
# Renaming Indexes
To rename an index, you may use the renameIndex method provided by the schema
builder blueprint. This method accepts the current index name as its first argument
and the desired name as its second argument:
$table->renameIndex('from', 'to')
If your application is utilizing an SQLite database, you must install the

doctrine/dbal package via the Composer package manager before the
renameIndex method may be used.
# Dropping Indexes
To drop an index, you must specify the index's name. By default, Laravel
automatically assigns an index name based on the table name, the name of the
indexed column, and the index type. Here are some examples:
Command Description
Drop a primary key from the
$table->dropPrimary('users_id_primary');
"users" table.
Drop a unique index from

$table->dropUnique('users_email_unique');
the "users" table.
Drop a basic index from the

$table->dropIndex('geo_state_index');
"geo" table.
Drop a full text index from

$table->dropFullText('posts_body_fulltext');
the "posts" table.
Drop a spatial index from

$table->dropSpatialIndex('geo_location_spatialindex'); the "geo" table (except
SQLite).
If you pass an array of columns into a method that drops indexes, the conventional
index name will be generated based on the table name, columns, and index type:
Schema::table('geo', function (Blueprint $table) {

$table->dropIndex(['state']); // Drops index 'geo_state_index'
});
# Foreign Key Constraints

Laravel also provides support for creating foreign key constraints, which are used
to force referential integrity at the database level. For example, let's define a
user_id column on the posts table that references the id column on a users table:
Schema::table('posts', function (Blueprint $table) {

$table->unsignedBigInteger('user_id');
$table->foreign('user_id')->references('id')->on('users');
});
Since this syntax is rather verbose, Laravel provides additional, terser methods that
use conventions to provide a better developer experience. When using the
foreignId method to create your column, the example above can be rewritten like
so:

$table->foreignId('user_id')->constrained();
});
The foreignId method creates an UNSIGNED BIGINT equivalent column, while the
constrained method will use conventions to determine the table and column name
being referenced. If your table name does not match Laravel's conventions, you
may specify the table name by passing it as an argument to the constrained
method:

$table->foreignId('user_id')->constrained('users');
});
You may also specify the desired action for the "on delete" and "on update"
properties of the constraint:
$table->foreignId('user_id')
->constrained()
->onUpdate('cascade')
->onDelete('cascade');
An alternative, expressive syntax is also provided for these actions:
Method Description
$table->cascadeOnUpdate(); Updates should cascade.
$table->restrictOnUpdate(); Updates should be restricted.
$table->cascadeOnDelete(); Deletes should cascade.
$table->restrictOnDelete(); Deletes should be restricted.
$table->nullOnDelete(); Deletes should set the foreign key value to null.
Any additional column modifiers must be called before the constrained method:
$table->foreignId('user_id')
->nullable()
->constrained();
# Dropping Foreign Keys
To drop a foreign key, you may use the dropForeign method, passing the name of
the foreign key constraint to be deleted as an argument. Foreign key constraints
use the same naming convention as indexes. In other words, the foreign key
constraint name is based on the name of the table and the columns in the
constraint, followed by a "_foreign" suffix:
$table->dropForeign('posts_user_id_foreign');
Alternatively, you may pass an array containing the column name that holds the
foreign key to the dropForeign method. The array will be converted to a foreign key
constraint name using Laravel's constraint naming conventions:
$table->dropForeign(['user_id']);
# Toggling Foreign Key Constraints
You may enable or disable foreign key constraints within your migrations by using
the following methods:
Schema::enableForeignKeyConstraints();
Schema::disableForeignKeyConstraints();
Schema::withoutForeignKeyConstraints(function () {
// Constraints disabled within this closure...
});
SQLite disables foreign key constraints by default. When using SQLite, make
sure to enable foreign key support in your database configuration before
attempting to create them in your migrations. In addition, SQLite only supports
foreign keys upon creation of the table and not when tables are altered.
# Events
For convenience, each migration operation will dispatch an event. All of the
following events extend the base Illuminate\Database\Events\MigrationEvent class:
Class Description
Illuminate\Database\Events\MigrationsStarted A batch of migrations is about to be
Class Description
executed.
A batch of migrations has finished

Illuminate\Database\Events\MigrationsEnded
executing.
A single migration is about to be

Illuminate\Database\Events\MigrationStarted
executed.
A single migration has finished

Illuminate\Database\Events\MigrationEnded
executing.
A database schema dump has

Illuminate\Database\Events\SchemaDumped
completed.
An existing database schema dump has

Illuminate\Database\Events\SchemaLoaded
loaded.
Laravel is a web application framework with expressive, elegant

syntax. We believe development must be an enjoyable and
creative experience to be truly fulfilling. Laravel attempts to take
the pain out of development by easing common tasks used in
most web projects.
HIGHLIGHTS RESOURCES
Our Team Laravel Bootcamp
Release Notes Laracasts
Getting Started Laravel News
Routing Laracon
Blade Templates Laracon EU
Authentication Laracon India
Authorization Jobs
Artisan Console Forums
Database Trademark
Eloquent ORM
Testing
PARTNERS ECOSYSTEM
WebReinvent Cashier
Vehikl Dusk
Tighten Echo
64 Robots Envoyer
Active Logic Forge
Byte 5 Horizon
Curotec Nova
Cyber-Duck Octane
DevSquad Sail
Jump24 Sanctum
Kirschbaum Scout
Spark
Telescope
Valet
Vapor
Laravel est une marque déposée de Taylor Otwell. Copyright © 2011-2023 Laravel LLC.
Surlignage de code fourni par Torchlight

Base de Données - Migrations - Laravel - Le Framework PHP Pour Les Artisans Du Web Doc Officiel de Laravel

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Base de Données - Migrations - Laravel - Le Framework PHP Pour Les Artisans Du Web Doc Officiel de Laravel

Transféré par

Droits d'auteur :

Formats disponibles

27/03/2023 02:56 Base de données : Migrations - Laravel - Le framework PHP pour les artisans du web

AVERTISSEMENT Vous parcourez la documentation d'une ancienne version de

Base de données : Migrations

# Écraser les migrations

# Restauration des migrations

# Mise à jour des tableaux

# Renommer / supprimer des tables

# Types de colonnes disponibles

# Modification des colonnes

# Renommer les colonnes

# Renommer les index

# Contraintes de clé étrangère

La Schema façade Laravel fournit une prise en charge indépendante de la base de

php artisan make:migration create_flights_table

Laravel utilisera le nom de la migration pour tenter de deviner le nom de la table et

Si vous souhaitez spécifier un chemin personnalisé pour la migration générée, vous

Les talons de migration peuvent être personnalisés à l'aide de la publication

# Écraser les migrations

php artisan schema:dump

correspondra à la connexion à la base de données. Maintenant, lorsque vous

Si les tests de votre application utilisent une connexion à la base de données

php artisan schema:dump

L'écrasement de la migration n'est disponible que pour les bases de données

Une classe de migration contient deux méthodes : up et down . La up méthode est

return new class extends Migration

# Définition de la connexion de migration

php artisan migrate

php artisan migrate:status

php artisan migrate --pretend

Isoler l'exécution de la migration

php artisan migrate --isolated

Pour utiliser cette fonctionnalité , votre application doit utiliser le pilote de

# Forcer les migrations à s'exécuter en production

Certaines opérations de migration sont destructives, ce qui signifie qu'elles

php artisan migrate --force

# Restauration des migrations

php artisan migrate:rollback

php artisan migrate:rollback --step=5

La migrate:reset commande annulera toutes les migrations de votre application :

php artisan migrate:reset

# Restauration et migration à l'aide d'une seule commande

La migrate:refresh commande annulera toutes vos migrations, puis exécutera la

php artisan migrate:refresh

# Refresh the database and run all database seeds...

Vous pouvez annuler et migrer à nouveau un nombre limité de migrations en

php artisan migrate:refresh --step=5

# Supprimer toutes les tables et migrer

La migrate:fresh commande supprimera toutes les tables de la base de données,

php artisan migrate:fresh

php artisan migrate:fresh --seed

La migrate:fresh commande supprimera toutes les tables de la base de

Schema::create('users', function (Blueprint $table) {

Lors de la création de la table, vous pouvez utiliser n'importe quelle méthode de

# Vérification de l'existence d'une table/colonne

# Connexion à la base de données et options de table

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

Schema::create('users', function (Blueprint $table) {

Schema::create('users', function (Blueprint $table) {

Schema::create('calculations', function (Blueprint $table) {

Si vous souhaitez ajouter un "commentaire" à une table de base de données, vous

table ne sont actuellement pris en charge que par MySQL et Postgres :

Schema::create('calculations', function (Blueprint $table) {

# Mise à jour des tableaux