Comment interroger les tables connectées dans Laravel

Laravel est un framework PHP populaire qui offre un moyen élégant de créer des applications Web et des API. Lors du processus de création d'applications, il est souvent nécessaire d'effectuer des requêtes associées entre les tables afin d'obtenir davantage d'informations sur les données. Cet article se concentrera sur la façon d'utiliser Laravel pour effectuer des requêtes de jointure de table.

1. Classe de modèles de base

Dans Laravel, chaque relation est établie par des méthodes entre des modèles liés. Nous devons définir des méthodes de relation dans la classe modèle. L'exemple suivant montre comment définir les méthodes de relation appartiennentTo et hasMany dans une classe de modèle.

class User extends Model
{
    /**
     * Get the post that belongs to the user.
     */
    public function post()
    {
        return $this->belongsTo(Post::class);
    }
}

class Post extends Model
{
    /**
     * Get the comments for the blog post.
     */
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }
}

Dans le modèle User, la méthode AppartientTo indique que le modèle User a un modèle Post, tandis que dans le modèle Post, la méthode hasMany indique que le modèle Post a plusieurs modèles Comment.

2. Requête relationnelle

Dans Laravel, le générateur de requêtes fournit certaines méthodes pour effectuer des requêtes relationnelles. Par exemple, nous pouvons utiliser la méthode with pour obtenir les données du modèle associé.

$users = User::with('post')->get();

Ce code obtiendra tous les modèles utilisateur et préchargera les modèles Post associés à l'aide de la méthode with. De cette manière, nous pouvons établir une relation entre l’utilisateur et la publication.

De même, nous pouvons également effectuer des requêtes de relation entre la publication et le commentaire.

$posts = Post::with('comments')->get();

Ce code obtiendra tous les modèles de publication et préchargera les modèles de commentaires associés en utilisant la méthode with.

Si nous devons filtrer davantage les résultats de la requête, nous pouvons transmettre la fonction de fermeture dans la méthode. L'exemple ci-dessous montre comment obtenir tous les commentaires publiés.

$comments = Comment::with(['post' => function ($query) {
    $query->where('published', true);
}])->get();

Ce code obtiendra tous les modèles de commentaires et préchargera les modèles de publication associés en utilisant la méthode with. Dans la méthode with, nous pouvons également transmettre un tableau associatif. À ce stade, les clés du tableau représentent le nom de la relation et les valeurs du tableau représentent la fonction de fermeture de requête de la relation actuelle.

3. Requête de relation personnalisée

Dans certains cas, nous devrons peut-être effectuer des requêtes personnalisées. Par exemple, nous devons interroger en fonction du rôle de l'utilisateur. À ce stade, nous pouvons définir une méthode de relation dans la classe modèle.

class User extends Model
{
    /**
     * Get the posts for the user by role.
     */
    public function postsByRole($role)
    {
        return $this->hasManyThrough(
            'App\Post', 
            'App\Category', 
            'user_id', 
            'category_id'
        )->where('role', '=', $role);
    }
}

Dans cet exemple, nous définissons une méthode postsByRole dans le modèle User. Cette méthode utilise la méthode hasManyThrough pour établir la relation entre le modèle Posts et le modèle Categories. Parmi eux, le premier paramètre représente le modèle Posts, le deuxième paramètre représente le modèle Categories, le troisième paramètre représente le nom de clé étrangère du modèle User à partir duquel le modèle Posts peut être obtenu, et le quatrième paramètre représente le modèle Posts à partir duquel le modèle Catégories peut être obtenu.

4. Relation plusieurs-à-plusieurs

Dans Laravel, les relations plusieurs-à-plusieurs sont établies via des tables intermédiaires. Dans la classe modèle, nous devons définir la méthode de relation AppartientToMany pour créer une relation plusieurs-à-plusieurs. L'exemple suivant montre comment établir une relation plusieurs-à-plusieurs entre le modèle User et le modèle Role.

class User extends Model
{
    /**
     * The roles that belong to the user.
     */
    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }
}

class Role extends Model
{
    /**
     * The users that belong to the role.
     */
    public function users()
    {
        return $this->belongsToMany(User::class);
    }
}

Dans le modèle User, la méthode AppartientToMany indique qu'une relation plusieurs-à-plusieurs est établie entre le modèle User et le modèle Role. De même, dans le modèle Role, la méthode AppartientToMany indique qu'une relation plusieurs-à-plusieurs est établie entre le modèle Role et le modèle User.

Concernant la requête de relations plusieurs-à-plusieurs, Laravel propose quelques méthodes à implémenter, telles que : withCount, has,whereHas, etc.

5. Conclusion

Cet article se concentre sur la façon d'effectuer des requêtes associées entre des tables dans Laravel, y compris les classes de modèles de base, les requêtes relationnelles, les requêtes relationnelles personnalisées et les requêtes relationnelles plusieurs-à-plusieurs. J'espère qu'en étudiant cet article, les lecteurs pourront maîtriser les connaissances de base de la requête de table de jointure de Laravel et être capables de l'appliquer de manière flexible dans des projets réels.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!