Laravel Many to Many Eloquent Relationship

Many to Many relationship is a little more complicated than one-to-one and one-to-many relationship, but don’t worry I will cover each and every point so can better understand.

To make the many to many eloquent relationship in laravel, you need three tables. Two tables will have their own data and the third table will have the data of both tables which links each other. You can also say the intermediate table or pivot table.

So in this tutorial, I will show you how to make many to many eloquent relationship and uses cases of getting, inserting, updating, or deleting the records from database tables.

There are more other types of eloquent relationships and each type has a different role of use. All are easy to use but the polymorphic relationship is a bit complicated. But you don’t need to worry about that I will explain in easy ways one by one in laravel tutorial.

• One to One Eloquent Relationship
• One to Many Eloquent Relationship
• Many to Many Eloquent Relationship

Let’s get started!!!

Laravel Many To Many Eloquent Relationship Example

So in this example tutorial, we will create three tables ‘users‘, ‘roles‘, and ‘role_user‘. The ‘role_user‘ table is the pivot table and the name should be alphabetically ordered of related model names.

Why do we need a ‘role_user’ table???

It is a very good question and mostly asked in interviews about this eloquent relationship. So we used the ‘role_user‘ table because we cannot directly add the ‘user_id‘ column in the ‘roles‘ table. If we do that then it would mean a role could only belong to a single user.

So in this tutorial guide, we will use the belongsToMany() method to make a many to many eloquent relationship.

So let’s get started with creating a laravel application, migrations, models and then make a many-to-many eloquent relationship.

Create a Laravel Application

First thing you need to create a new laravel application if you don’t have one. So use the following command to install the laravel application.

composer create-project laravel/laravel blog

Note: Make sure you have composer installed on your machine. If it’s not installed then see the full tutorial of laravel installation in more detail.

Create Migrations of Tables

After installation, we will create migration files for the database tables. Let’s create migrations for User, Role, and RoleUser models.

Run the following commands in your terminal to create the migration files. It will create two files in the /database/migrations folder.

php artisan make:migration CreateUsersTable

php artisan make:migration CreateRolesTable

php artisan make:migration CreateRoleUserTable

See Also: Create Laravel Model, Migration, Controller, and Resource in One Command

Now you have to add the columns in these files as you want. For this tutorial, we are taking the following migration example files for ‘users‘, ‘roles‘, and ‘role_user‘ tables.

Schema::create('users', function (Blueprint $table) {
    $table->increments('id');
    $table->string('name');
    $table->string('email')->unique();
    $table->string('password');
    $table->rememberToken();
    $table->timestamps();
});

Schema::create('roles', function (Blueprint $table) {
    $table->increments('id');
    $table->string('name');
    $table->timestamps();
});

Schema::create('role_user', function (Blueprint $table) {
    $table->integer('user_id')->unsigned();
    $table->integer('role_id')->unsigned();
    $table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');
    $table->foreign('role_id')->references('id')->on('roles')->onDelete('cascade');
    $table->timestamps();
});

You see above we have created the table structure of three tables in migration files. You also may have noticed that we used onDelete('cascade') and references() methods. Basically, the references() method is used to refer the foreign key to another table’s primary key and onDelete(‘cascade’) method is used to delete the relational data.

So after making the changes in migration files, now you have to run the following command to create the database tables using these migration files structures.

php artisan migrate

See Also: How to Create Database Table Using Migration in Laravel?

Create Models ‘User’, ‘Role’ and ‘RoleUser’

Now let’s create models of User, Role and RoleUser where we will define the eloquent methods respectively. So run the following commands to make models.

php artisan make:model User

php artisan make:model Role

php artisan make:model RoleUser

After creating the models, let’s define the relational methods in User and Role models to link with each other and the RoleUser model.

<?php

namespace App\Models;

use Illuminate\Notifications\Notifiable;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Database\Eloquent\Model;
use App\Models\Role;

class User extends Authenticatable
{
    use Notifiable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name', 'email', 'password'
    ];

    /**
     * The attributes that should be hidden for arrays.
     *
     * @var array
     */
    protected $hidden = [
        'password', 'remember_token',
    ];

    /**
     * Get the comments associated with the post.
     */
    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }
}

In the above model we define the roles() method using the belongsToMany() method that has an argument as a relative model class. Now you can access the roles of users using the roles dynamic property.

Now if you want to get all users that have a specific role then you have to do the same thing in the Role model. See the following code for the Role model.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use App\Models\User;

class Role extends Model

{
    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name'
    ];

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

In this above model, we define the users() method using the belongsToMany() method and passed the first argument as a relative model class.

Note: The belongsToMany() method automatically determine the relationship’s intermediate table name that joins the two table. But if you have a different name for an intermediate table then you can pass the second argument as the intermediate table name.

return $this->belongsToMany(Role::class, 'role_user');
return $this->belongsToMany(User::class, 'role_user');

You can further customize the belongsToMany() method if you had added the different key columns in the RoleUser model. The third argument is the foreign key name of the model on which you are defining the relationship, while the fourth argument is the foreign key name of the model that you are joining.

return $this->belongsToMany(Role::class, 'role_user', 'user_id', 'role_id');

Now add some dummy data manually that has proper relation between each table or you can use the laravel database seeder feature it will create dummy data for you.

Create ‘MainController’ and Call Methods

Now you have to create a controller to call those methods to get the results accordingly. Use the following commands to create a controller.

php artisan make:controller MainController

The above command will create the controller file like the following. And now you are ready to get the user’s role or user by role by creating the function for API and calling them.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Role;
use App\Models\User;

class MainController extends Controller
{
    public function get_roles($user_id)
    {
        $user = User::find($user_id);
        foreach ($user->roles as $role) {
            echo $role->pivot->name;
        }
    }

    public function get_users($role_id)
    {
        $role = Role::find($role_id);
        foreach ($role->users as $user) {
            echo $user->pivot->email;
        }
    }
}

As you notice that in the above controller methods we used the pivot attribute to get the data of the linked table. Actually, this pivot attribute represents the intermediate model and it is automatically assigned when you are getting the data in many to many relationship.

There are more filters with pivot attribute in advance that you can check on the laravel’s official documentation for details.

Create Routes to Get the Records

To create the routes, go to the /routes folder and open the web.php file. In this file, you can create routes for your application. Add the following two routes in this file.

use App\Http\Controllers\MainController;

Route::get('get-roles/{user_id}', [MainController::class, 'get_roles']);
Route::get('get-users/{role_id}', [MainController::class, 'get_users']);

Now you can call these APIs by starting the laravel application using the php artisan serve command and using the following URLs in your browser.

# get roles by user id
http://localhost:8000/get-roles/1

# get users by role id
http://localhost:8000/get-users/1

Hope your code will run flawlessly!!!

Conclusion

So in this tutorial, you learned about many to many laravel eloquent relationship to join the three tables each other and one of them has an intermediate table.

You also learned how to create a laravel application, migration, models, and controller to make the many to many eloquent relationship in laravel. And we used the belongsToMany() method in models by passing the argument as a relative model class and more customizations with it.