La relation "HasManyThrough" dans Laravel

La relation "HasManyThrough" est utilisée pour définir une relation de type "HasMany" à travers une autre table intermédiaire. Cela permet d'accéder à des enregistrements associés à un modèle à travers un autre modèle.

La relation "BelongsToMany" est utilisée lorsqu'un modèle peut appartenir à plusieurs autres modèles, et vice versa, à travers une table pivot. C'est une relation de plusieurs à plusieurs. Dans l'exemple précédent, la relation entre les modèles User et Group est un exemple de "BelongsToMany". Chaque utilisateur peut appartenir à plusieurs groupes, et chaque groupe peut avoir plusieurs utilisateurs. La table pivot user_group joue un rôle intermédiaire pour enregistrer ces associations.

En résumé, "HasManyThrough" est utilisée pour définir une relation de type "HasMany" à travers une table intermédiaire, tandis que "BelongsToMany" est utilisée pour définir une relation de plusieurs à plusieurs à travers une table pivot.

Différences entre HasMany et HasManyThrough

HasMany

Définition :
La relation "HasMany" est utilisée pour définir une relation où un modèle possède plusieurs instances d'un autre modèle.
Exemple :
Dans une application de blog, un auteur peut avoir plusieurs articles. Dans ce cas, la relation "HasMany" serait utilisée pour représenter la relation entre le modèle "Author" et le modèle "Article".

// Modèle Author
public function articles()
{
    return $this->hasMany(Article::class);
}

Cette relation permet d'accéder à tous les articles associés à un auteur via la méthode articles.

HasManyThrough

Définition :
La relation "HasManyThrough" est utilisée pour définir une relation "HasMany" à travers un autre modèle intermédiaire. Cela est utile lorsque les modèles ne sont pas directement liés, mais peuvent être reliés via un modèle intermédiaire.
Exemple :
Prenons l'exemple précédent de la gestion d'écoles, de cours et d'étudiants. Si vous souhaitez accéder à tous les étudiants d'une école donnée, la relation "HasManyThrough" serait utilisée.

// Modèle School
public function students()
{
    return $this->hasManyThrough(Student::class, Course::class);
}

Cette relation permet d'accéder à tous les étudiants d'une école à travers la relation entre les cours et les étudiants.

Différences clés :

Structure de la base de données :
HasMany : Dans la relation "HasMany", les modèles sont généralement directement liés par la clé étrangère dans la table du modèle enfant (exemple : clé étrangère author_id dans la table articles).
HasManyThrough : Dans la relation "HasManyThrough", les modèles ne sont pas directement liés par une clé étrangère commune. Une table intermédiaire est utilisée pour connecter les deux modèles.
Utilisation :

HasMany : Utilisé lorsque les modèles sont directement liés et que chaque instance du modèle parent peut avoir plusieurs instances du modèle enfant.
HasManyThrough : Utilisé lorsque les modèles ne sont pas directement liés, mais peuvent être reliés via un modèle intermédiaire.

Exemple supplémentaire :

HasMany : Chaque école a plusieurs étudiants.
HasManyThrough : Chaque école a plusieurs cours, et chaque cours a plusieurs étudiants.

En résumé, la principale différence réside dans la manière dont les modèles sont reliés dans la base de données. "HasMany" est utilisé lorsque les modèles sont directement liés, tandis que "HasManyThrough" est utilisé lorsque les modèles ne sont pas directement liés et nécessitent une table intermédiaire pour établir la connexion.

Exemple 1

un exemple de la relation "HasManyThrough" dans le contexte d'une application de gestion d'écoles, où chaque école a plusieurs cours et chaque cours a plusieurs étudiants. Les tables associées seront schools, courses, students, et une table intermédiaire course_school.

Migration pour la table schools :

// database/migrations/YYYY_MM_DD_create_schools_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('schools', function (Blueprint $table) {
            $table->id('idSchool'); // Nommer la clé primaire avec idTable
            $table->string('name');
            $table->string('location');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('schools');
    }
}

Migration pour la table courses :

// database/migrations/YYYY_MM_DD_create_courses_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('courses', function (Blueprint $table) {
            $table->id('idCourse'); // Nommer la clé primaire avec idTable
            $table->string('name');
            $table->unsignedBigInteger('school_id'); // Clé étrangère

            $table->foreign('school_id')->references('idSchool')->on('schools');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('courses');
    }
}

Migration pour la table students :

// database/migrations/YYYY_MM_DD_create_students_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('students', function (Blueprint $table) {
            $table->id('idStudent'); // Nommer la clé primaire avec idTable
            $table->string('name');
            $table->unsignedBigInteger('course_id'); // Clé étrangère

            $table->foreign('course_id')->references('idCourse')->on('courses');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('students');
    }
}

Migration pour la table pivot course_school :

// database/migrations/YYYY_MM_DD_create_course_school_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('course_school', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('course_id');
            $table->unsignedBigInteger('school_id');
            
            $table->foreign('course_id')->references('idCourse')->on('courses');
            $table->foreign('school_id')->references('idSchool')->on('schools');
            
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('course_school');
    }
}

Modèle pour la table School :

// app/Models/School.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class School extends Model
{
    protected $table = 'schools';
    protected $primaryKey = 'idSchool'; // Nommer la clé primaire avec idTable
    protected $fillable = ['name', 'location'];

    public function courses()
    {
        return $this->hasManyThrough(Course::class, CourseSchool::class, 'school_id', 'idCourse', 'idSchool', 'course_id');
    }
}

Modèle pour la table Course :

// app/Models/Course.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Course extends Model
{
    protected $table = 'courses';
    protected $primaryKey = 'idCourse'; // Nommer la clé primaire avec idTable
    protected $fillable = ['name', 'school_id'];

    public function students()
    {
        return $this->hasMany(Student::class, 'course_id', 'idStudent');
    }

    public function schools()
    {
        return $this->belongsToMany(School::class, 'course_school', 'course_id', 'school_id');
    }
}

Modèle pour la table Student :

// app/Models/Student.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Student extends Model
{
    protected $table = 'students';
    protected $primaryKey = 'idStudent'; // Nommer la clé primaire avec idTable
    protected $fillable = ['name', 'course_id'];

    public function course()
    {
        return $this->belongsTo(Course::class, 'course_id', 'idCourse');
    }
}

Modèle pour la table pivot CourseSchool :

// app/Models/CourseSchool.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class CourseSchool extends Model
{
    protected $table = 'course_school';
    protected $fillable = ['course_id', 'school_id'];
}

Dans cet exemple, chaque école (School) a plusieurs cours (Course), et chaque cours a plusieurs étudiants (Student). La méthode hasManyThrough dans le modèle School définit la relation "HasManyThrough", permettant d'accéder aux étudiants associés à une école.