Que sont les relations dans Eloquent ?<\/h2>\n
Lorsque vous travaillez avec des tables dans une base de donn\u00e9es relationnelle, nous pouvons caract\u00e9riser les relations comme des connexions entre les tables. Cela vous aide \u00e0 organiser et \u00e0 structurer les donn\u00e9es sans effort, ce qui permet une meilleure lisibilit\u00e9 et une meilleure manipulation des donn\u00e9es. En pratique, il existe trois types de relations dans les bases de donn\u00e9es :<\/p>\n
- \n
- une \u00e0 une – Un enregistrement dans une table est associ\u00e9 \u00e0 une, et une seule, dans une autre table. Par exemple, une personne et un num\u00e9ro de s\u00e9curit\u00e9 sociale.<\/li>\n<\/ul>\n
- \n
- une-\u00e0-plusieurs – Un enregistrement est associ\u00e9 \u00e0 plusieurs enregistrements dans une autre table. Par exemple, un \u00e9crivain et ses blogs.<\/li>\n<\/ul>\n
- \n
- plusieurs \u00e0 plusieurs – Plusieurs enregistrements d’une table sont associ\u00e9s \u00e0 plusieurs enregistrements d’une autre table. Par exemple, les \u00e9tudiants et les cours auxquels ils sont inscrits.<\/li>\n<\/ul>\n
Laravel permet d’interagir et de g\u00e9rer les relations entre les bases de donn\u00e9es en utilisant la syntaxe orient\u00e9e objet d’Eloquent.<\/p>\n
En plus de ces d\u00e9finitions, Laravel introduit d’autres relations, \u00e0 savoir :<\/p>\n
- \n
- Has Many Through<\/li>\n
- Relations polymorphes<\/li>\n
- Plusieurs-\u00e0-plusieurs Polymorphes<\/li>\n<\/ul>\n
Prenons l’exemple d’un magasin dont l’inventaire contient une vari\u00e9t\u00e9 d’articles, chacun dans sa propre cat\u00e9gorie. Il est donc logique, d’un point de vue commercial, de diviser la base de donn\u00e9es en plusieurs tables. Cela pose des probl\u00e8mes, car vous ne souhaitez pas interroger chaque table.<\/p>\n
Nous pouvons facilement cr\u00e9er une simple relation un-\u00e0-plusieurs dans Laravel pour nous aider, par exemple lorsque nous avons besoin d’interroger les produits, nous pouvons le faire en utilisant le mod\u00e8le Product.<\/p>\n
![\"Sch\u00e9ma](\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/05\/pasted-image-0-6.png\")
Sch\u00e9ma de base de donn\u00e9es avec trois tables et une table commune repr\u00e9sentant une relation polymorphe<\/figcaption><\/figure>\n Relation un-\u00e0-un<\/h2>\n
Premi\u00e8re relation de base propos\u00e9e par Laravel, elle associe deux tables de mani\u00e8re \u00e0 ce qu’une ligne de la premi\u00e8re table soit corr\u00e9l\u00e9e \u00e0 une seule ligne de l’autre table.<\/p>\n
Pour voir cela en action, nous devons cr\u00e9er deux mod\u00e8les avec leur propre migration :<\/p>\n
php artisan make:model Tenant \nPhp artisan make:model Rent<\/code><\/pre>\n\u00c0 ce stade, nous avons deux mod\u00e8les, l’un \u00e9tant le locataire et l’autre son loyer.<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Tenant extends Model\n{\n \/**\n * Get the rent of a Tenant\n *\/\n public function rent() \n {\n return $this->hasOne(Rent::class);\n }\n}<\/code><\/pre>\nComme Eloquent d\u00e9termine la relation de cl\u00e9 \u00e9trang\u00e8re en se basant sur le nom du mod\u00e8le parent (Tenant dans ce cas), le mod\u00e8le Rent suppose qu’il existe une cl\u00e9 \u00e9trang\u00e8re tenant_id.<\/strong><\/p>\n
Nous pouvons facilement l’\u00e9craser en ajoutant un argument suppl\u00e9mentaire \u00e0 la m\u00e9thode hasOne<\/strong>:<\/p>\n
return $this- >hasOne(Rent::class, \"custom_key\");<\/code><\/pre>\nEloquent suppose \u00e9galement qu’il existe une correspondance entre la cl\u00e9 \u00e9trang\u00e8re d\u00e9finie et la cl\u00e9 primaire du parent (mod\u00e8le Tenant). Par d\u00e9faut, il cherchera \u00e0 faire correspondre tenant_id<\/strong> avec la cl\u00e9 id<\/strong> de l’enregistrement Tenant. Nous pouvons remplacer cela par un troisi\u00e8me argument dans la m\u00e9thode hasOne<\/strong>, de mani\u00e8re \u00e0 ce qu’il corresponde \u00e0 une autre cl\u00e9 :<\/p>\n
return $this->hasOne(Rent::class, \"custom_key\", \"other_key\"); <\/code><\/pre>\nMaintenant que nous avons d\u00e9fini la relation biunivoque entre les mod\u00e8les, nous pouvons l’utiliser facilement, comme ci-dessous :<\/p>\n
$rent = Tenant::find(10)->rent;<\/code><\/pre>\nAvec cette ligne de code, nous obtenons le loyer du locataire avec l’identifiant 10 s’il existe.<\/p>\n
Relation d’un \u00e0 plusieurs<\/h2>\n
Comme la relation pr\u00e9c\u00e9dente, celle-ci d\u00e9finira les relations entre un mod\u00e8le monoparental et plusieurs mod\u00e8les enfants. Il est peu probable que notre locataire n’ait qu’une seule facture de loyer, car il s’agit d’un paiement r\u00e9current ; il aura donc plusieurs paiements.<\/p>\n
Dans ce cas, notre relation pr\u00e9c\u00e9dente pr\u00e9sente des d\u00e9fauts et nous pouvons les corriger :<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Tenant extends Model\n{\n \/**\n * Get the rents of a Tenant\n *\/\n public function rent() \n {\n return $this->hasMany(Rent::class);\n }\n}<\/code><\/pre>\nAvant d’appeler la m\u00e9thode pour obtenir les loyers, il est bon de savoir que les relations servent \u00e0 construire des requ\u00eates, de sorte que nous pouvons ajouter des contraintes (comme un loyer entre deux dates, un paiement minimum, etc :<\/p>\n
$rents = Tenant::find(10)->rent()->where('payment', '>', 500)->first();<\/code><\/pre>\nEt comme pour la relation pr\u00e9c\u00e9dente, nous pouvons \u00e9craser les cl\u00e9s \u00e9trang\u00e8res et locales en passant des arguments suppl\u00e9mentaires :<\/p>\n
return $this->hasMany(Rent::class, \"foreign_key\");<\/code><\/pre>\nreturn $this->hasMany(Rent::class, \"foreign_key\", \"local_key\");<\/code><\/pre>\nNous disposons d\u00e9sormais de tous les loyers d’un locataire, mais que faire lorsque nous connaissons le loyer et que nous voulons savoir \u00e0 qui il appartient ? Nous pouvons utiliser la propri\u00e9t\u00e9 belongsTo <\/strong>:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Rent extends Model\n{\n \/**\n * Return the tenant for the rent\n *\/\n public function tenant() \n {\n return $this->belongsTo(Tenant::class);\n }\n}<\/code><\/pre>\nEt maintenant, nous pouvons facilement trouver le locataire :<\/p>\n
$tenant = Rent::find(1)->tenant;<\/code><\/pre>\nPour la m\u00e9thode belongsTo<\/strong>, nous pouvons \u00e9galement \u00e9craser les cl\u00e9s \u00e9trang\u00e8res et locales comme nous l’avons fait pr\u00e9c\u00e9demment.<\/p>\n
Relation de type un sur plusieurs (Has-One-Of-Many)<\/h2>\n
\u00c9tant donn\u00e9 que notre mod\u00e8le Locataire peut \u00eatre associ\u00e9 \u00e0 de nombreux mod\u00e8les Location, nous voulons facilement r\u00e9cup\u00e9rer le mod\u00e8le le plus r\u00e9cent ou le plus ancien des relations.<\/p>\n
Une fa\u00e7on pratique de le faire est de combiner les m\u00e9thodes hasOne<\/strong> et ofMany <\/strong>:<\/p>\n
public function latestRent() {\n return $this->hasOne(Rent::class)->latestOfMany();\n}\n\npublic function oldestRent() {\n return $this->hasOne(Rent::class)->oldestOfMany();\n}<\/code><\/pre>\nPar d\u00e9faut, nous r\u00e9cup\u00e9rons les donn\u00e9es sur la base de la cl\u00e9 primaire, qui peut \u00eatre tri\u00e9e, mais nous pouvons cr\u00e9er nos propres filtres pour la m\u00e9thode ofMany <\/strong>:<\/p>\n
return $this->hasOne(Rent::class)->ofMany('price', 'min');<\/code><\/pre>\nRelations HasOneThrough et HasManyThrough<\/h2>\n
Les m\u00e9thodes -Through <\/strong>sugg\u00e8rent que nos mod\u00e8les devront passer par un autre mod\u00e8le pour \u00e9tablir une relation avec le mod\u00e8le souhait\u00e9. Par exemple, nous pouvons associer le loyer au propri\u00e9taire, mais le loyer doit d’abord passer par le locataire pour atteindre le propri\u00e9taire.<\/p>\n
Les cl\u00e9s des tables n\u00e9cessaires \u00e0 cet effet ressembleraient \u00e0 ceci :<\/p>\n
rent\n id - integer\n name - string\n value - double\n\ntenants\n id - integer\n name - string\n rent_id - integer\n\nlandlord\n id - integer\n name - string\n tenant_id - integer<\/code><\/pre>\nApr\u00e8s avoir visualis\u00e9 l’aspect de nos tables, nous pouvons cr\u00e9er les mod\u00e8les :<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Rent extends Model\n{\n \/**\n * Return the rents' landlord\n *\/\n public function rentLandlord() \n {\n return $this->hasOneThrough(Landlord::class, Tenant::class);\n }\n}<\/code><\/pre>\nLe premier argument de la m\u00e9thode hasOneThrough<\/strong> est le mod\u00e8le auquel vous voulez acc\u00e9der, et le deuxi\u00e8me argument est le mod\u00e8le que vous allez traverser.<\/p>\n
Et comme pr\u00e9c\u00e9demment, vous pouvez \u00e9craser les cl\u00e9s \u00e9trang\u00e8res et locales. Maintenant que nous avons deux mod\u00e8les, nous en avons deux de chaque \u00e0 \u00e9craser dans cet ordre :<\/p>\n
public function rentLandlord() \n{\n return $this->hasOneThrough(\n Landlord::class,\n Tenant::class,\n \"rent_id\", \/\/ Foreign key on the tenant table\n \"tenant_id\", \/\/ Foreign key on the landlord table\n \"id\", \/\/ Local key on the tenant class\n \"id\" \/\/ Local key on the tenant table\n );\n}<\/code><\/pre>\nDe m\u00eame, la relation \u00ab Has Many Through \u00bb de Laravel Eloquent est utile lorsque vous souhaitez acc\u00e9der aux enregistrements d’une table distante par le biais d’une table interm\u00e9diaire. Prenons un exemple avec trois tables :<\/p>\n
- \n
- country<\/li>\n
- users<\/li>\n
- games<\/li>\n<\/ul>\n
Chaque pays a plusieurs utilisateurs et chaque utilisateur a plusieurs jeux. Nous voulons r\u00e9cup\u00e9rer tous les jeux appartenant \u00e0 un pays dans la table users<\/p>\n
Vous devez d\u00e9finir les tables comme suit :<\/p>\n
country\n id - integer\n name - string\n\nuser\n id - integer\n country_id - integer\n name - string\n\ngames\n id - integer\n user_id - integer\n title - string<\/code><\/pre>\nVous devez maintenant d\u00e9finir le mod\u00e8le Eloquent pour chaque table :<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Country extends Model\n{\n protected $fillable = ['name'];\n\n public function users()\n {\n return $this->hasMany(User::class);\n }\n\n public function games()\n {\n return $this->hasManyThrough(Games::class, User::class);\n }\n}<\/code><\/pre>\n<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass User extends Model\n{\n protected $fillable = [article_id, 'name'];\n\n public function country()\n {\n return $this->belongsTo(Country::class);\n }\n\n public function posts()\n {\n return $this->hasMany(Post::class);\n }\n}<\/code><\/pre>\n<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Game extends Model\n{\n protected $fillable = ['user_id', 'title'];\n\n public function user()\n {\n return $this->belongsTo(User::class);\n }\n}<\/code><\/pre>\nNous pouvons maintenant appeler la m\u00e9thode games() <\/strong>du mod\u00e8le Pays pour obtenir tous les jeux, car nous avons \u00e9tabli la relation \u00ab Has Many Through \u00bb entre Pays et Jeu par l’interm\u00e9diaire du mod\u00e8le Utilisateur.<\/p>\n
<?php\n\n$country = Country::find(159);\n \n\/\/ Retrieve all games for the country\n$games = $country->games;<\/code><\/pre>\nRelation de plusieurs \u00e0 plusieurs<\/h2>\n
La relation de plusieurs \u00e0 plusieurs est plus compliqu\u00e9e. Un bon exemple est celui d’un employ\u00e9 qui a plusieurs r\u00f4les. Un r\u00f4le peut \u00e9galement \u00eatre attribu\u00e9 \u00e0 plusieurs employ\u00e9s. C’est la base de la relation de plusieurs \u00e0 plusieurs.<\/p>\n
Pour cela, nous devons disposer des tables employees<\/strong>, roles<\/strong> et role_employees <\/strong>.<\/p>\n
La structure des tables de notre base de donn\u00e9es se pr\u00e9sente comme suit :<\/p>\n
employees\n id - integer\n name - string\n\nroles \n id - integer\n name - string\n\nrole_employees\n user_id - integer\n role_id - integer<\/code><\/pre>\nEn connaissant la structure des tables de la relation, nous pouvons facilement d\u00e9finir notre mod\u00e8le Employ\u00e9<\/strong> comme appartenant \u00e0 plusieurs<\/strong> mod\u00e8les<\/strong> R\u00f4le<\/strong>.<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Employee extends Model\n{\n public function roles() \n {\n return $this- >belongsToMany(Role::class);\n }\n}<\/code><\/pre>\nUne fois cette d\u00e9finition effectu\u00e9e, nous pouvons acc\u00e9der \u00e0 tous les r\u00f4les d’un employ\u00e9 et m\u00eame les filtrer :<\/p>\n
$employee = Employee::find(1);\n$employee->roles->forEach(function($role) { \/\/ });\n\n\/\/ OR \n\n$employee = Employee::find(1)->roles()->orderBy('name')->where('name', 'admin')->get();<\/code><\/pre>\nComme toutes les autres m\u00e9thodes, nous pouvons \u00e9craser les cl\u00e9s \u00e9trang\u00e8res et locales de la m\u00e9thode belongsToMany<\/strong>.<\/p>\n
Pour d\u00e9finir la relation inverse de la m\u00e9thode belongsToMany<\/strong>, il suffit d’utiliser la m\u00eame m\u00e9thode, mais sur la m\u00e9thode enfant, avec le parent comme argument.<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Role extends Model\n{\n public function employees() \n {\n return $this->belongsToMany(Employee::class);\n }\n}<\/code><\/pre>\nUtilisations de la table interm\u00e9diaire<\/h3>\n
Comme nous l’avons peut-\u00eatre remarqu\u00e9, lorsque nous utilisons la relation plusieurs-\u00e0-plusieurs, nous sommes toujours cens\u00e9s avoir une table interm\u00e9diaire. Dans ce cas, nous utilisons la table role_employees<\/strong>.<\/p>\n
Par d\u00e9faut, notre tableau crois\u00e9 dynamique ne contient que les attributs id. Si nous voulons d’autres attributs, nous devons les sp\u00e9cifier comme suit :<\/p>\n
return $this->belongsToMany(Employee::class)->withPivot(\"active\", \"created_at\");<\/code><\/pre>\nSi nous voulons raccourcir le tableau crois\u00e9 dynamique pour les horodatages, nous pouvons le faire :<\/p>\n
return $this->belongsToMany(Employee::class)->withTimestamps();<\/code><\/pre>\nIl faut savoir que nous pouvons personnaliser le nom \u00ab pivot \u00bb pour qu’il corresponde mieux \u00e0 notre application :<\/p>\n
return $this->belongsToMany(Employee::class)->as('subscription')->withPivot(\"active\", \"created_by\");<\/code><\/pre>\nFiltrer les r\u00e9sultats d’une requ\u00eate \u00e9loquente est un must pour tout d\u00e9veloppeur qui souhaite am\u00e9liorer son jeu et optimiser ses applications Laravel<\/a>.<\/p>\n
C’est pourquoi Laravel propose une fonctionnalit\u00e9 fantastique, les pivots, qui peuvent \u00eatre utilis\u00e9s pour filtrer les donn\u00e9es que nous voulons collecter. Ainsi, au lieu d’utiliser d’autres fonctionnalit\u00e9s comme les transactions de base de donn\u00e9es<\/a> pour obtenir nos donn\u00e9es en morceaux, nous pouvons les filtrer avec des m\u00e9thodes utiles comme wherePivot, wherePivotIn, wherePivotNotIn, wherePivotBetween, wherePivotNotBetween, wherePivotNull, wherePivotNotNull<\/strong> et nous pouvons les utiliser lors de la d\u00e9finition des relations entre les tables !<\/p>\n
return $this->belongsToMany(Employee::class)->wherePivot('promoted', 1);\nreturn $this->belongsToMany(Employee::class)->wherePivotIn('level', [1, 2]);\nreturn $this->belongsToMany(Employee::class)->wherePivotNotIn('level', [2, 3]);\nreturn $this->belongsToMany(Employee::class)->wherePivotBetween('posted_at', ['2023-01-01 00:00:00', '2023-01-02 00:00:00']);\nreturn $this->belongsToMany(Employee::class)->wherePivotNull('expired_at');\nreturn $this->belongsToMany(Employee::class)->wherePivotNotNull('posted_at');<\/code><\/pre>\nUne derni\u00e8re fonctionnalit\u00e9 \u00e9tonnante est la possibilit\u00e9 de classer les pivots :<\/p>\n
return $this->belongsToMany(Employee::class)\n ->where('promoted', true)\n ->orderByPivot('hired_at', 'desc');<\/code><\/pre>\nRelations polymorphes<\/h2>\n
Le mot \u00ab polymorphe \u00bb vient du grec et signifie \u00ab plusieurs formes \u00bb Ainsi, un mod\u00e8le dans notre application peut prendre plusieurs formes, ce qui signifie qu’il peut avoir plus d’une association. Imaginez que nous construisions une application avec des blogs, des vid\u00e9os, des sondages, etc. Un utilisateur peut cr\u00e9er un commentaire pour chacun de ces \u00e9l\u00e9ments. Un utilisateur peut cr\u00e9er un commentaire pour n’importe lequel de ces \u00e9l\u00e9ments. Par cons\u00e9quent, un mod\u00e8le Commentaire<\/strong> peut appartenir aux mod\u00e8les Blogs<\/strong>, Vid\u00e9os<\/strong> et Sondages<\/strong>.<\/p>\n
Polymorphe un \u00e0 un<\/h2>\n
Ce type de relation est similaire \u00e0 une relation univoque standard. La seule diff\u00e9rence est que le mod\u00e8le enfant peut appartenir \u00e0 plusieurs types de mod\u00e8les avec une seule association.<\/p>\n
Prenez, par exemple, un mod\u00e8le Locataire <\/strong>et Propri\u00e9taire<\/strong>, il peut partager une relation polymorphe avec un mod\u00e8le Facture d’eau<\/strong>.<\/p>\n
La structure de la table peut \u00eatre la suivante :<\/p>\n
tenants\n id \u2013 integer\n name \u2013 string\n\nlandlords\n id \u2013 integer\n name \u2013 string\n\nwaterbills\n id \u2013 integer\n amount \u2013 double\n waterbillable_id\n waterbillable_type<\/code><\/pre>\nNous utilisons waterbillable_id pour l’identifiant du propri\u00e9taire <\/strong>ou du locataire, <\/strong>tandis que waterbillable_type contient le nom de la classe du mod\u00e8le parent. La colonne type est utilis\u00e9e par Eloquent pour d\u00e9terminer le mod\u00e8le parent \u00e0 retourner.<\/p>\n
La d\u00e9finition du mod\u00e8le pour une telle relation se pr\u00e9sente comme suit :<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass WaterBill extends Model\n{\n public function billable()\n {\n return $this->morphTo();\n }\n}\n\nclass Tenant extends Model\n{\n public function waterBill() \n {\n return $this->morphOne(WaterBill::class, 'billable');\n }\n}\n\nclass Landlord extends Model\n{\n public function waterBill() \n {\n return $this->morphOne(WaterBill::class, 'billable');\n }\n}<\/code><\/pre>\nUne fois que tout cela est en place, nous pouvons acc\u00e9der aux donn\u00e9es du mod\u00e8le du propri\u00e9taire et du locataire :<\/p>\n
<?php\n\n$tenant = Tenant::find(1)->waterBill;\n$landlord = Landlord::find(1)->waterBill;<\/code><\/pre>\nUne relation polymorphe de type un \u00e0 plusieurs<\/h2>\n
Il s’agit d’une relation similaire \u00e0 une relation classique de type \u00ab un \u00e0 plusieurs \u00bb, la seule diff\u00e9rence essentielle \u00e9tant que le mod\u00e8le enfant peut appartenir \u00e0 plusieurs types de mod\u00e8les, en utilisant une seule association.<\/p>\n
Dans une application comme Facebook, les utilisateurs peuvent commenter des messages, des vid\u00e9os, des sondages, des \u00e9v\u00e9nements en direct, etc. Avec une association polymorphe, nous pouvons utiliser une seule table de commentaires<\/strong> pour stocker les commentaires de toutes les cat\u00e9gories que nous avons. La structure de notre table ressemblerait \u00e0 ceci :<\/p>\n
posts \n id \u2013 integer\n title \u2013 string\n body \u2013 text\n\nvideos\n id \u2013 integer\n title \u2013 string\n url \u2013 string\n\npolls\n id \u2013 integer\n title \u2013 string\n\ncomments \n id \u2013 integer\n body \u2013 text\n commentable_id \u2013 integer\n commentable_type \u2013 string<\/code><\/pre>\nLe commentable_id \u00e9tant l’identifiant de l’enregistrement, et le commentable_type \u00e9tant le type de classe, de sorte qu’eloquent sache ce qu’il doit chercher. Quant \u00e0 la structure du mod\u00e8le, elle est tr\u00e8s similaire \u00e0 la structure polymorphe one-to-many :<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Comment extends Model \n{\n public function commentable()\n {\n return $this->morphTo();\n }\n}\n\nclass Poll extends Model\n{\n public function comments()\n {\n return $this->morphMany(Comment::class, 'commentable');\n }\n}\n\nclass Live extends Model\n{\n public function comments()\n {\n return $this->morphMany(Comments::class, 'commentable');\n }\n}<\/code><\/pre>\nMaintenant, pour r\u00e9cup\u00e9rer les commentaires d’un Live, nous pouvons simplement appeler la m\u00e9thode find avec l’id, et nous avons maintenant acc\u00e8s \u00e0 la classe it\u00e9rable comments :<\/p>\n
<?php\n\nuse App<\/span>\\Models\\Live;\n\n$live = Live::find(1);\n\nforeach ($live->comments as $comment) { }\n\n\/\/ OR\n\nLive::find(1)->comments()->each(function($comment) { \/\/ });\nLive::find(1)->comments()->map(function($comment) { \/\/ });\nLive::find(1)->comments()->filter(function($comment) { \/\/ });\n\n\/\/ etc.<\/code><\/pre>\nEt si nous avons le commentaire et que nous voulons savoir \u00e0 qui il appartient, nous acc\u00e9dons \u00e0 la m\u00e9thode commentable :<\/p>\n
<?php\n\nuse App<\/span>\\Models\\Comment<\/span>;\n\n$comment = Comment::find(10);\n$commentable = $comment->commentable;\n\n\/\/ commentable \u2013 type of Post, Video, Poll, Live<\/code><\/pre>\nPolymorphe un \u00e0 d’autres<\/h2>\n
Dans de nombreuses applications qui \u00e9voluent, nous voulons un moyen facile d’interagir avec les mod\u00e8les et entre eux. Nous pouvons vouloir conna\u00eetre le premier ou le dernier message d’un utilisateur, ce qui peut \u00eatre fait avec une combinaison de m\u00e9thodes morphOne<\/strong> et ofMany <\/strong>:<\/p>\n
<?php\n\npublic function latestPost()\n{\n return $this->morphOne(Post::class, 'postable')->latestOfMany();\n}\n\npublic function oldestPost()\n{\n return $this->morphOne(Post::class, 'postable')->oldestOfMany();\n}<\/code><\/pre>\nLes m\u00e9thodes latestOfMany<\/strong> et oldestOfMany <\/strong>r\u00e9cup\u00e8rent le mod\u00e8le le plus r\u00e9cent ou le plus ancien en fonction de la cl\u00e9 primaire du mod\u00e8le, qui \u00e9tait la condition pour qu’il puisse \u00eatre tri\u00e9.<\/p>\n
Dans certains cas, nous ne voulons pas trier par l’ID, peut-\u00eatre avons-nous chang\u00e9 la date de publication de certains articles et nous les voulons dans cet ordre, pas par leur ID.<\/p>\n
Pour ce faire, vous pouvez passer deux param\u00e8tres \u00e0 la m\u00e9thode ofMany<\/strong>. Le premier param\u00e8tre est la cl\u00e9<\/strong> par laquelle nous voulons filtrer, et le second est la m\u00e9thode de tri <\/strong>:<\/p>\n
<?php\n\npublic function latestPublishedPost()\n{\n return $this->morphOne(Post::class, \"postable\")->ofMany(\"published_at\", \"max\");\n}<\/code><\/pre>\nEn gardant cela \u00e0 l’esprit, il est possible de construire des relations plus avanc\u00e9es pour cela ! Imaginez le sc\u00e9nario suivant. On nous demande de g\u00e9n\u00e9rer une liste de tous les articles actuels dans l’ordre dans lequel ils ont \u00e9t\u00e9 publi\u00e9s. Le probl\u00e8me se pose lorsque deux articles ont la m\u00eame valeur published_at et lorsque des articles sont programm\u00e9s pour \u00eatre publi\u00e9s dans le futur.<\/p>\n
Pour cela, nous pouvons passer l’ordre dans lequel nous voulons que les filtres soient appliqu\u00e9s \u00e0 la m\u00e9thode ofMany<\/strong>. De cette mani\u00e8re, nous classons les articles par published_at, et s’ils sont identiques, nous les classons par id. Deuxi\u00e8mement, nous pouvons appliquer une fonction de requ\u00eate \u00e0 la m\u00e9thode ofMany<\/strong> pour exclure tous les articles dont la publication est programm\u00e9e !<\/p>\n
<?php\n\npublic function currentPosts()\n{\n return $this->hasOne(Post::class)->ofMany([\n 'published_at' => 'max',\n 'id' => 'max',\n ], function ($query) {\n $query->where('published_at', '<', now());\n });\n}<\/code><\/pre>\nPolymorphe plusieurs \u00e0 plusieurs<\/h2>\n
Le many-to-many polymorphe est l\u00e9g\u00e8rement plus complexe que le normal. Une situation courante est celle o\u00f9 les balises s’appliquent \u00e0 plusieurs actifs dans votre application. Par exemple, sur TikTok, nous avons des balises qui peuvent s’appliquer aux vid\u00e9os, aux courts m\u00e9trages, aux histoires, etc.<\/p>\n
La m\u00e9thode polymorphe many-to-many nous permet d’avoir une seule table de balises associ\u00e9es aux vid\u00e9os, aux courts-m\u00e9trages et aux histoires.<\/p>\n
La structure du tableau est simple :<\/p>\n
videos\n id \u2013 integer\n description \u2013 string\n\nstories \n id \u2013 integer\n description \u2013 string\n\ntaggables \n tag_id \u2013 integer\n taggable_id \u2013 integer\n taggable_type \u2013 string<\/code><\/pre>\nLes tables \u00e9tant pr\u00eates, nous pouvons cr\u00e9er le mod\u00e8le et utiliser la m\u00e9thode morphToMany<\/strong>. Cette m\u00e9thode accepte le nom de la classe du mod\u00e8le et le \u00ab nom de la relation \u00bb :<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Video extends Model\n{\n public function tags()\n {\n return $this->morphToMany(Tag::class, 'taggable');\n }\n}<\/code><\/pre>\nGr\u00e2ce \u00e0 cela, nous pouvons facilement d\u00e9finir la relation inverse. Nous savons que pour chaque mod\u00e8le enfant, nous voulons appeler la m\u00e9thode morphedByMany<\/strong>:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Tag extends Model\n{\n public function stories()\n {\n return $this->morphedByMany(Story::class, 'taggable');\n }\n\n public function videos()\n {\n return $this->morphedByMany(Video::class, 'taggable');\n } \n}<\/code><\/pre>\nEt maintenant, lorsque nous obtenons une balise, nous pouvons r\u00e9cup\u00e9rer toutes les vid\u00e9os et les histoires li\u00e9es \u00e0 cette balise !<\/p>\n
<?php\nuse App<\/span>\\Model<\/span>\\Tag<\/span>;\n\n$tag = Tag::find(10);\n$posts = $tag->stories;\n$videos = $tag->stories;<\/code><\/pre>\nOptimisez Eloquent pour plus de rapidit\u00e9<\/h2>\n
Lorsque vous travaillez avec l’ORM Eloquent de Laravel, il est essentiel de comprendre comment optimiser les requ\u00eates de base de donn\u00e9es et minimiser le temps et la m\u00e9moire n\u00e9cessaires pour r\u00e9cup\u00e9rer les donn\u00e9es. L’une des fa\u00e7ons d’y parvenir est d’impl\u00e9menter la mise en cache<\/a> dans votre application.<\/p>\n
Laravel fournit un syst\u00e8me de mise en cache flexible qui prend en charge diff\u00e9rents backends, tels que Redis<\/a>, Memcached<\/a> et la mise en cache bas\u00e9e sur les fichiers<\/a>. En mettant en cache les r\u00e9sultats des requ\u00eates Eloquent, vous pouvez r\u00e9duire le nombre de requ\u00eates de base de donn\u00e9es, ce qui rend votre application plus rapide et plus utile.<\/p>\n
En outre, vous pouvez utiliser le constructeur de requ\u00eates<\/a> de Laravel pour cr\u00e9er des requ\u00eates complexes suppl\u00e9mentaires, optimisant ainsi les performances de votre application.<\/p>\n
En r\u00e9sum\u00e9<\/h2>\n
En conclusion, les relations Eloquent sont une fonctionnalit\u00e9 puissante de Laravel qui permet aux d\u00e9veloppeurs de travailler facilement avec des donn\u00e9es li\u00e9es. Qu’il s’agisse de relations un \u00e0 un ou plusieurs \u00e0 plusieurs, Eloquent fournit une syntaxe simple et intuitive pour d\u00e9finir et interroger ces relations.<\/p>\n
En tant que d\u00e9veloppeur Laravel, la ma\u00eetrise des relations Eloquent peut consid\u00e9rablement am\u00e9liorer votre flux de d\u00e9veloppement et rendre votre code plus efficace et plus lisible. Si vous souhaitez en savoir plus sur Laravel, Kinsta met \u00e0 votre disposition diverses ressources, notamment un tutoriel<\/a> sur la prise en main de Laravel et un article sur les salaires des d\u00e9veloppeurs Laravel<\/a>.<\/p>\n
- plusieurs \u00e0 plusieurs – Plusieurs enregistrements d’une table sont associ\u00e9s \u00e0 plusieurs enregistrements d’une autre table. Par exemple, les \u00e9tudiants et les cours auxquels ils sont inscrits.<\/li>\n<\/ul>\n
- une-\u00e0-plusieurs – Un enregistrement est associ\u00e9 \u00e0 plusieurs enregistrements dans une autre table. Par exemple, un \u00e9crivain et ses blogs.<\/li>\n<\/ul>\n