Laravel relaciones muchos a muchos

dagsis

Planteamiento

Para este tutorial se usará de ejemplo un sistema que gestiona alumnos en una escuela, este sistema cuenta con dos modelos, Estudiante y Curso en donde un estudiante puede tener muchos cursos y un curso puede contar con muchos estudiantes. En este ejemplo aplica la relación de «muchos a muchos». En los siguientes pasos verás cómo implementar las relaciones «muchos a muchos» (Many to Many) en Laravel:

1. Crear modelos, migraciones y tabla intermedia

Cuando trabajas con relaciones de muchos a muchos es necesario crear una tabla intermedia o pivote la cual relaciona el id del modelo Estudiante y el id del modelo Curso. Primero crea el modelo Estudiante y su migración, para ello abre una terminal de comandos en la raíz de tu proyecto en Laravel y ejecuta la instrucción:

php artisan make:model Estudiante -m

Para crear el modelo Curso y su migración:

php artisan make:model Curso -m

Ahora para crear la tabla intermedia o tabla pivote recuerda que debe ser llamada como los modelos y en orden alfabético en este caso se llama curso_estudiante ya que curso es primero alfabéticamente que estudiante y siempre en singular. Ejecuta el siguiente comando:

php artisan make:migration create_curso_estudiante_table

2. Configurar migraciones

Con el editor de textos de tu preferencia abre el archivo database/migrations/…create_estudiantes_table.php y agrega el campo ‘name’ y ‘first_name’ para que quede así:

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

$table->id();

$table->string('name');

$table->string('last_name');

$table->timestamps();

});

Toca configurar el archivo database/migrations/…create_cursos_table.php al cual para este ejemplo solo le agregarás el campo ‘name’:

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

$table->id();

$table->string('name');

$table->timestamps();

});

Ahora abre el archivo database/migrations/…create_curso_estudiante_table.php que es la tabla intermedia en donde se crearán las relaciones con las tablas cursos y estudiantes:

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

$table->id();

$table->unsignedBigInteger('curso_id');

$table->foreign('curso_id')->references('id')->on('cursos')->onDelete('cascade');

$table->unsignedBigInteger('estudiante_id');

$table->foreign('estudiante_id')->references('id')->on('estudiantes')->onDelete('cascade');

$table->timestamps();

});

En el anterior código el método unsignedBigInteger() asigna al campo curso_id un tipo de dato entero, positivo y soporta un valor muy grande. El método foreign() define la llave foránea y la relación entre los campos curso_id de la tabla curso_estudiante y el campo id de la tabla cursos.

3. Relacionar los modelos Estudiante y Curso

Toca crear las relaciones entre Estudiante y Curso a nivel de modelo, para ello abre el archivo app/Models/Estudiante.php y como un estudiante puede tener muchos cursos se usa el método en plural y se utiliza belongsToMany(). Agrega la función estudiantes() al archivo:

//Relationships Many to Many

public function cursos(){

return $this->belongsToMany(Curso::class, 'curso_estudiante');

}

Para terminar de crear la relación a nivel modelo abre el archivo app/Models/Curso.php y como un curso puede pertenecer a muchos estudiantes el nombre del método debe estar en plural y al igual que el método anterior se usa belongsToMany():

//Relationships Many to Many

public function estudiantes(){

return $this->belongsToMany(Estudiante::class, 'curso_estudiante');

}

4. Agregar datos de prueba

Para generar datos falsos de prueba voy a usar Factories para poblar las tablas de la base de datos, para crear el factory para el modelo Estudiante ejecuta la siguiente instrucción en la consola de comandos:

php artisan make:factory EstudianteFactory

Ahora para crear el factory para el modelo Curso:

php artisan make:factory CursoFactory

4.2 Configurar EstudianteFactory

Abre el archivo database/factories/EstudianteFactory.php y para agregar información falsa de prueba vas utilizar la librería Faker de Laravel para lo cual pega el siguiente código en tu archivo:

<?php

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

/**

* @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Estudiante>

class EstudianteFactory extends Factory

{

/**

* Define the model's default state.

* @return array<string, mixed>

public function definition()

{

return [

'name' => $this->faker->name(),

'last_name' => $this->faker->lastName(),

];

}

4.3 Configurar CursoFactory

En el archivo database/factories/CursoFactory.php dentro del método definition() en el array return agrega la siguiente línea de código para generar los nombres falsos para los cursos:

'name' => $this->faker->sentence(2)

4.3 Configurar archivo DatabaseSeeder

Abre el archivo database/seeders/DatabaseSeeder.php y al inicio importa los modelos Estudiante y Curso:

use App\Models\Curso;

use App\Models\Estudiante;

El siguiente código es un factory que crea datos falsos de prueba haciendo uso de las relaciones «muchos a muchos» (Many to Many) en Laravel, crea 15 estudiantes, 8 cursos y cada curso es tomado 3 estudiantes con los cuales son relacionados en la tabla intermedia. Dentro del método run() agrega las siguiente líneas de código:

//Se crean 15 estudiantes

Estudiante::factory()->times(15)->create();

//Se crean 8 cursos

Curso::factory()->times(8)->create()->each( function($curso){

$curso->estudiantes()->sync(

//Cada curso es tomado por 3 estudiantes

Estudiante::all()->random(3)

);

});

Para correr las migraciones y poblar las tablas ejecuta la siguiente instrucción:

php artisan migrate:fresh --seed

Abre tu cliente de gestión de base de datos como PHPMyAdmin, Heidi o MySQLWorkbench y verás que las tablas estudiantes y cursos se han poblado de datos y en la tabla intermedia o pivote están las relaciones de cursos y estudiantes a través de su id.

5. Probar las relaciones muchos a muchos (Many to Many) en Laravel

Laravel como el gran marco de desarrollo que es cuenta con un buen número de herramientas que facilitan el trabajo y Tinker es una de ellas. Con Tinker harás consultas desde la terminal de comandos para probar las relaciones en la base de datos y modelos, para llamar a Tinker ejecuta la instrucción:

php artisan tinker

Para consultar todos los registros de los estudiantes escribe:

Estudiantes::all();

Si quieres ver todos los cursos que se han registrado en la base de datos ejecuta la instrucción:

Cursos::all();

Ahora consulta un estudiante en específico como el que tiene el id 11:

$estudiante = Estudiante::find(11);

Consulta los cursos a los que el estudiante de id 11 está inscrito ejecutando:

$estudiante->cursos

Para ver los estudiantes que están inscritos en un curso específico:

$curso = Curso::find(5);

Accediendo a través de la relación muchos a muchos:

$curso->estudiantes

Se muestran todos los estudiantes que pertenecen a este curso. Las relaciones de las tablas están funcionando correctamente a nivel base de datos y a nivel modelos.

Laravel relaciones muchos a muchos

Planteamiento

1. Crear modelos, migraciones y tabla intermedia

2. Configurar migraciones

3. Relacionar los modelos Estudiante y Curso

4. Agregar datos de prueba

4.2 Configurar EstudianteFactory

4.3 Configurar CursoFactory

4.3 Configurar archivo DatabaseSeeder

5. Probar las relaciones muchos a muchos (Many to Many) en Laravel

Related Post

Modelo de datos en laravel

Migraciones en laravel

Datatable

Eloquent ORM en Laravel

Laravel Lang

0 Comments

Leave a comment

Categories

Recent Post

Consultas Sql Gestion

Reparacion del servicio de Sql

COMANDO MYSQL

Get In Touch

Address

Email

Phone

Quick Links

Newsletter