Recherche…
Interroger sur les relations
Eloquent vous permet également d'interroger sur des relations définies, comme indiqué ci-dessous:
User::whereHas('articles', function (Builder $query) {
$query->where('published', '!=', true);
})->get();
Cela nécessite que le nom de votre méthode de relation soit des articles dans ce cas. L'argument transmis dans la fermeture est le Générateur de requêtes pour le modèle associé. Vous pouvez donc utiliser toutes les requêtes que vous pouvez trouver ailleurs.
Envie de chargement
Supposons que le modèle Utilisateur ait une relation avec le modèle Article et que vous souhaitez charger les articles associés. Cela signifie que les articles de l'utilisateur seront chargés lors de la récupération de l'utilisateur.
articles est le nom de la relation (méthode) dans le modèle utilisateur.
User::with('articles')->get();
si vous avez plusieurs relations. par exemple des articles et des articles.
User::with('articles','posts')->get();
et pour sélectionner des relations imbriquées
User::with('posts.comments')->get();
Appeler plusieurs relations imbriquées
User::with('posts.comments.likes')->get()
Insertion de modèles associés
Supposons que vous ayez un modèle Post avec une relation hasMany avec Comment . Vous pouvez insérer un objet Comment associé à une publication en procédant comme suit:
$post = Post::find(1);
$commentToAdd = new Comment(['message' => 'This is a comment.']);
$post->comments()->save($commentToAdd);
Vous pouvez enregistrer plusieurs modèles à la fois en utilisant la fonction saveMany :
$post = Post::find(1);
$post->comments()->saveMany([
new Comment(['message' => 'This a new comment']),
new Comment(['message' => 'Me too!']),
new Comment(['message' => 'Eloquent is awesome!'])
]);
Il existe également une méthode create qui accepte un tableau PHP simple au lieu d'une instance de modèle Eloquent.
$post = Post::find(1);
$post->comments()->create([
'message' => 'This is a new comment message'
]);
introduction
Les relations éloquentes sont définies comme des fonctions sur vos classes de modèles Eloquent. Étant donné que, tout comme les modèles Eloquent eux-mêmes, les relations servent également de puissants générateurs de requêtes, la définition de relations en tant que fonctions fournit de puissantes fonctions de chaînage et d'interrogation de méthodes. Par exemple, nous pouvons enchaîner des contraintes supplémentaires sur cette relation d'articles:
$user->posts()->where('active', 1)->get();
Types de relation
Un à plusieurs
Disons que chaque message peut avoir un ou plusieurs commentaires et chaque commentaire appartient à un seul message.
donc la table de commentaires aura post_id . Dans ce cas, les relations seront les suivantes.
Post modèle
public function comments()
{
return $this->belongsTo(Post::class);
}
Si la clé étrangère est autre que post_id , par exemple la clé étrangère est example_post_id .
public function comments()
{
return $this->belongsTo(Post::class, 'example_post_id');
}
et plus, si la clé locale est autre que id , par exemple la clé locale est other_id
public function comments()
{
return $this->belongsTo(Post::class, 'example_post_id', 'other_id');
}
Modèle de commentaire
définition inverse de un à plusieurs
public function post()
{
return $this->hasMany(Comment::class);
}
Un par un
Comment associer deux modèles (exemple: modèle User et Phone )
App\User
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{
/**
* Get the phone record associated with the user.
*/
public function phone()
{
return $this->hasOne('Phone::class', 'foreign_key', 'local_key');
}
}
App\Phone
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Phone extends Model
{
/**
* Get the user that owns the phone.
*/
public function user()
{
return $this->belongsTo('User::class', 'foreign_key', 'local_key');
}
}
foreign_key : Par défaut, Eloquent supposera que cette valeur est other_model_name_id (dans ce cas, user_id et phone_id ), modifiez-le si ce n'est pas le cas.
local_key : Par défaut, Eloquent supposera que cette valeur est id (clé primaire du modèle actuel), modifiez-la si ce n'est pas le cas.
Si votre nom de base de données est déposé conformément au standard Laravel, vous n'avez pas besoin de fournir de déclaration de clé étrangère et de clé locale dans la relation
Explication
Plusieurs à plusieurs
Disons qu'il y a des rôles et des autorisations. Chaque rôle peut appartenir à de nombreuses autorisations et chaque autorisation peut appartenir à plusieurs rôles. il y aura donc 3 tables. deux modèles et un tableau pivotant. une table roles , users et permission_role .
Modèle
public function permissions()
{
return $this->belongsToMany(Permission::class);
}
Modèle d'autorisation
public function roles()
{
return $this->belongsToMany(Roles::class);
}
Note 1
envisagez de suivre tout en utilisant un nom de table différent pour le tableau croisé dynamique.
Supposons que vous souhaitiez utiliser role_permission au lieu de permission_role , car eloquent utilise l'ordre alphabétique pour construire les noms de clés pivot. Vous devrez passer le nom du tableau croisé comme second paramètre comme suit.
Modèle
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission');
}
Modèle d'autorisation
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission');
}
Note 2
envisagez de suivre tout en utilisant différents noms de clés dans le tableau croisé dynamique.
Eloquent suppose que si aucune clé n'est passée en troisième et quatrième paramètres, ce seront les noms de table singulier avec _id . il suppose donc que le pivot aura les champs role_id et permission_id . Si des clés autres que celles-ci doivent être utilisées, elles doivent être transmises en troisième et quatrième paramètres.
Disons que other_role_id au lieu de role_id et other_permission_id au lieu de permission_id doivent être utilisés. Ce serait donc comme suit.
Modèle
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id');
}
Modèle d'autorisation
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission', 'other_permission_id', 'other_role_id');
}
Polymorphe
Les relations polymorphes permettent à un modèle d'appartenir à plusieurs autres modèles sur une même association. Un bon exemple serait les images, à la fois un utilisateur et un produit peuvent avoir une image. La structure de la table peut ressembler à ceci:
user
id - integer
name - string
email - string
product
id - integer
title - string
SKU - string
image
id - integer
url - string
imageable_id - integer
imageable_type - string
Les colonnes importantes à examiner se trouvent dans le tableau des images. La colonne imageable_id contiendra la valeur d'ID de l'utilisateur ou du produit, tandis que la colonne imageable_type contiendra le nom de la classe du modèle propriétaire. Dans vos modèles, vous configurez les relations comme suit:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Image extends Model
{
/**
* Get all of the owning imageable models.
*/
public function imageable()
{
return $this->morphTo();
}
}
class User extends Model
{
/**
* Get all of the user's images.
*/
public function images()
{
return $this->morphMany('Image::class', 'imageable');
}
}
class Product extends Model
{
/**
* Get all of the product's images.
*/
public function images()
{
return $this->morphMany('Image::class', 'imageable');
}
}
Vous pouvez également récupérer le propriétaire d'une relation polymorphe à partir du modèle polymorphe en accédant au nom de la méthode qui effectue l'appel à morphTo . Dans notre cas, c'est la méthode imageable sur le modèle Image. Nous allons donc accéder à cette méthode en tant que propriété dynamique
$image = App\Image::find(1);
$imageable = $image->imageable;
Cet imageable renverra un utilisateur ou un produit.
Plusieurs à plusieurs
Disons qu'il y a des rôles et des autorisations. Chaque rôle peut appartenir à de nombreuses autorisations et chaque autorisation peut appartenir à plusieurs rôles. il y aura donc 3 tables. deux modèles et un tableau pivotant. une table roles , users et permission_role .
Modèle
public function permissions()
{
return $this->belongsToMany(Permission::class);
}
Modèle d'autorisation
public function roles()
{
return $this->belongsToMany(Roles::class);
}
Note 1
envisagez de suivre tout en utilisant un nom de table différent pour le tableau croisé dynamique.
Supposons que vous souhaitiez utiliser role_permission au lieu de permission_role , car eloquent utilise l'ordre alphabétique pour construire les noms de clés pivot. Vous devrez passer le nom du tableau croisé comme second paramètre comme suit.
Modèle
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission');
}
Modèle d'autorisation
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission');
}
Note 2
envisagez de suivre tout en utilisant différents noms de clés dans le tableau croisé dynamique.
Eloquent suppose que si aucune clé n'est passée en troisième et quatrième paramètres, ce seront les noms de table singulier avec _id . il suppose donc que le pivot aura les champs role_id et permission_id . Si des clés autres que celles-ci doivent être utilisées, elles doivent être transmises en troisième et quatrième paramètres.
Disons que other_role_id au lieu de role_id et other_permission_id au lieu de permission_id doivent être utilisés. Ce serait donc comme suit.
Modèle
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id');
}
Modèle d'autorisation
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission', 'other_permission_id', 'other_role_id');
}
Accéder à la table intermédiaire avec withPivot ()
Supposons que vous avez une troisième colonne ' permission_assigned_date ' dans le tableau croisé dynamique. Par défaut, seules les clés de modèle seront présentes sur l'objet pivot. Maintenant, pour obtenir cette colonne dans le résultat de la requête, vous devez ajouter le nom avec la fonction withPivot ().
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id')->withPivot('permission_assigned_date');
}
Fixation / Détachement
Eloquent propose également quelques méthodes d'aide supplémentaires pour faciliter le travail avec les modèles associés. Par exemple, imaginons qu'un utilisateur puisse avoir plusieurs rôles et qu'un rôle puisse avoir de nombreuses autorisations. Pour associer un rôle à une autorisation en insérant un enregistrement dans la table intermédiaire qui joint les modèles, utilisez la méthode attach:
$role= App\Role::find(1);
$role->permissions()->attach($permissionId);
Lorsque vous associez une relation à un modèle, vous pouvez également transmettre un tableau de données supplémentaires à insérer dans la table intermédiaire:
$rol->roles()->attach($permissionId, ['permission_assigned_date' => $date]);
De même, pour supprimer une autorisation spécifique pour un rôle, utilisez la fonction de détachement
$role= App\Role::find(1);
//will remove permission 1,2,3 against role 1
$role->permissions()->detach([1, 2, 3]);
Associations de synchronisation
Vous pouvez également utiliser la méthode sync pour construire des associations plusieurs-à-plusieurs. La méthode sync accepte un tableau d'ID à placer sur la table intermédiaire. Tout identifiant qui ne figure pas dans le tableau donné sera supprimé de la table intermédiaire. Ainsi, une fois cette opération terminée, seuls les ID du tableau donné existeront dans la table intermédiaire:
//will keep permission id's 1,2,3 against Role id 1
$role= App\Role::find(1)
$role->permissions()->sync([1, 2, 3]);
