Laravel Relationship

An Eloquent relationship is a very important feature in Laravel that allows you to relate the tables in a very easy format.

One to one relationship

One to one relationship provides the one-to-one relationship between the columns of different tables. For example, every user is associated with a single post or maybe multiple posts, but in this relationship, we will retrieve the single post of a user. To define a relationship, we need first to define the post() method in User model. In the post() method, we need to implement the hasOne() method that returns the result.

Let's understand the one to one relationship through an example.

First, we add the new column (user_id) in an existing table named as posts. Here, user_id is the foreign key.

Migrate the above changes in a database by using the command given below:
php artisan migrate.
After the migration, the structure of the posts table is shown in the below screenshot:

The above screenshot shows that the user_id column is added successfully.

Open the User.php file and add the following code in the User.php file.

public function post()
{
  return $this->hasOne('App\Post');
}

In the above code, we have implemented the hasOne() method that contains the single argument, i.e., name of the related model. By default, the Post considers the user_id as a foreign key. The post() method searches the posts table as we have mentioned the namespace 'App/Post' and look for the column user_id. We can override this convention by providing a foreign key as a second argument. It can be re-written as:

return $this->hasOne('App\Post',foreign_key)

Now, we will add the route in the web.php file.

<?php
use App\User;
Route::get('/user',function()
{
  return User::find(1)->post;
}
);

The above code is finding the user with an id number 1 and then implementing the post to find the post of the user having user_id equal to 1.

Output

Inverse Relation

Inverse relation means the inverse of the one-to-one relationship. In the above, we have retrieved the post belonging to a particular user. Now, we retrieve the user information based on the post. Let's understand this through an example.

First, we create the route in the web.php file.

<?php
use App\Post;
Route::get('/post/user',function()
{
 return Post::find(1)->user->name;
});

Open the Post.php file(model) that we created earlier.

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
class Post extends Model
{
 use SoftDeletes;
protected $table='posts';
protected $primaryKey='id';
protected $fillable=
[
'title',
'body'
];
protected $dates=['deleted_at'];
public function user()
{
  return $this->belongsTo('App\User');
}

}

Output

One-to-many relationship

Laravel also provides a one-to-many relationship.

First, we define the route that finds out all the posts of a single user.

Route::get('/posts',function(){
$user=User::find(1);
foreach($user->posts as $post){
echo $post->title."<br>";
}
});

Add the following code in the User.php(model) file.

public function posts()
{
    return $this->hasMany('App\Post','user_id');
}

Output

Many-to-Many relationship

A many-to-many relationship is more complicated than a one-to-one relationship and a one-to-many relationship. To define the many-to-many relationship, we need to create a pivot table. The pivot table is basically a look up table that relates the two tables. For example, a user may have different roles where the roles can be shared by other users, like many users can have the role of 'Admin'. To define the relationship between the users and roles, we need to create the three tables, user, roles, and role_user. In our database, the user table is already created; we need to create two tables, i.e., roles table and pivot table (roles_user).

First, we create the Role model. We use the following command to create the model:
php artisan make:model Role -m

The above screen shows that the roles table has been created. The create_roles_table.php has been created in the database/migration directory. The structure of this file is given below:

<?php
 use Illuminate\Support\Facades\Schema;
 use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateRolesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('roles', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('roles');
    }
}

In the above code, we have added the new column named as 'name'. The 'name' column defines the name of the role of a user.

Now, we have two tables, the roles table, and the users table. To relate these two tables, we need to create the pivot table, roles_user table.

The above screen shows that the roles_user table has been created. The structure of the create_roles_user_table is given below:

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateRolesUserTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('roles_user', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->integer('user_id');
            $table->integer('role_id');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('roles_user');
    }
}

In the above code, we have added two new columns, user_id, and role_id.

Migrate all the above changes by using the command given below:
php artisan migrate

The below screen shows all the three tables, i.e., roles, roles_user, and users are created.

Data available in the roles table:

Data available in the users table:

Data available in the roles_user table:

Now, we define the route.

web.php

Route::get('/roles/{id}',function($id){
$user=User::find($id);
foreach($user->role as $role)
{
   return $role->name;
}
});

We add the following code in User.php file which relates both the tables.

public function role()
{
   return $this->belongsToMany('App\Role','roles_user');
} 

In the above code, belongsToMany() method contains two parameters, 'App\Role', which is the namespace to use the Role model, and 'roles_user' is the name of the pivot table that relates two tables. The belongsToMany() method can also be written as:

belongsToMany('App\Role','roles_user','user_id','role_id');

The above line contains two more parameters, user_id, and role_id. The user_id is the foreign key for the users table, and role_id is the foreign key for the roles table.

Output

Accessing the intermediate/pivot table

In many-to-many relationship, we create the pivot or intermediate table. Now, we will see how to retrieve this pivot table.

<?php
Use App\User;
Route::get('/pivot',function(){
$user=User::find(1);
foreach($user->role as $role)
{
   return $role->pivot;
}
});

In the above model, we are retrieving the user having an id equal to 1. Then, using the foreach loop, we are retrieving the role model and assigned in the pivot attribute.

If we want to retrieve the specific column from the pivot table,

public function role()
{
return $this->belongsToMany('App\Role','roles_user')->withPivot('created_at');
} 

web.php

Route::get('/pivot',function(){
$user=User::find(1);
foreach($user->role as $role)
{
   return $role->pivot->created_at;
}
});

Output

Has Many Through

The 'has many through' relationship provides a convenient way of accessing the distant or intermediate relations. For example, we have three tables, users, posts, and country table. Now, we want to find the posts belonging to that country through the User model.

Let's understand through an example.

The country table is not available in the database. We first create the country model with the database migration.

Add the 'name' column in country table.

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateCountriesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
            Schema::create('countries', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name');
            $table->timestamps();
        });
    }
/**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('countries');
    }
}

Migrate the above changes by using the command given below:
php artisan migrate
Now, we add the new column 'country_id' in users table. Use the command given below:
php artisan make:migration add_new_column_column_id -table=users;
After the execution of the above command, the add_new_column_column_id file is created in database/migrations directory.

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class AddNewColumnColumnId extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->integer('country_id')->unsigned;
        });
    }
 /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->dropColumn('country_id');
        });
    }
}

In the above code, we have added a new column in users table.

To migrate the above changes in the database,

php artisan migrate

Open the country.php(model) file. We are going to pull the posts of a specific country using the country model.
country.php

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class country extends Model
{
 public function posts(){   
 return $this->hasManyThrough('App\Post','App\User','country_id','user_id');
}
}

Now, we add the route that pulls out the posts of a specific country.

Route::get('/user/country',function()
{

   $country=country::find(1);
   foreach($country->posts as $post)
   {
     return $post->title;
   }
});

Output

Polymorphic relationship

One-to-many (Polymorphic)

The Polymorphic relationship is similar to the one-to-many relationship. When a single model belongs to more than one type of model on a single association is known as one-to-one polymorphic relationship. For example, if we have three tables, posts, users, and photo table, where photo table represents the polymorphic relation with the users and posts table.

Let's understand this relationship through an example.

We have already created the users and the posts table in the previous topic. Now, we create a photo table.

Open the create_photos_table.php file created in the migrations folder.

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreatePhotosTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('photos', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('path');
            $table->integer('imageable_id');
            $table->string('imageable_type');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('photos');
    }
}

In the above code, we have added three columns, path, imageable_id, and imageable_type. The path determines the path of the image, imageable_id is the id value of the user or post, and imageable_type is the class name of the model.

We will delete the user_id column from the posts table, which we have created previously.
Look at the database tables.

Data available in a posts table

Data available in users table:

Data available in photo table:

Open the Photo model file.

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class photo extends Model
{
//
public function imageable()
{
 return $this->morphTo();
}}

Add the following code in the User model file.

public function photos()
{
  return $this->morphMany('App\Photo','imageable');
}

Add the following code in the Post model file.

public function photos()
{
  return $this->morphMany('App\Photo','imageable');}

Now, we will create the routes for both users and posts.

// Route for the users.
Route::get('/user/photo',function(){
$user=User::find(1);
foreach($user->photos as $photo)
{
   return $photo;
}
});

// Route defined for the posts.
Route::get('/post/photo',function(){
$post=Post::find(1);
foreach($post->photos as $photo)
{
   return $photo;
}

});

Output

Inverse of one-to-many (polymorphic) relationship

In this topic, we will perform the inverse operation of the one-to-many polymorphic relationship. Till now, we found the image of the users and posts, now we find out the owner of the image.

Let's understand through an example.

We need to create the route in web.php file.

 Route::get('/photo/{id}', function($id)
{
   $photo=Photo::findOrFail($id);
   return $photo->imageable;
});

In the above code, Photo::findOrFail($id) method determines whether the photo of a given id exists or not. If exists, then it returns the details of the image through the statement, '$photo->imageable'.

Output

The above output shows the details of the image.

Many-to-many polymorphic relationship

In a many-to-many polymorphic relationship, a target model consists of unique records that are shared among the various models. For example, a tag table shares the polymorphic relation between the videos and the posts table. A tag table consists of the unique list of tags that are shared by both the tables, videos, and the posts table.

Let's understand through an example.

First, we create the models with database migration named as Audio, Tag, and Taggable.

After creating the models, we will edit their migrated files.

Open the migration file of the Audio table named as 'create_audio_table'.

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateAudioTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('audio', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('audio');
    }
}

In the above code, we have created the name column in the audio table by using the command $table->string('name');.

Open the migration file of the Tag model named as 'create_tag_table'.

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateTagsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('tags', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('tags');
    }
}

In the above code, we have created the name column in the tags table by using the command $table->string('name');.

Open the migration file of the Taggable model named as 'create_taggables_table'.

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreateTaggablesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('taggables', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->integer('tag_id');
            $table->integer('taggable_id');
            $table->string('taggable_type');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('taggables');
    }}

In the above code, we have added three new columns in the taggables table, i.e., tag_id, taggable_id, and taggable_type. The tag_id represents the id of the tag table, taggable id represents the id of the model table, and taggable type represents the name of the class.

To migrate the above changes, we use the command given below:
php artisan migrate
Look at the database table:

Data available in an audio table:

Data available in post table:

Data available in tags table:

Data available in taggables table:

Now we define the relationship on the model.

Audio.php

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Audio extends Model
{
  // get all the tags from the audio. 
  public function tags()
  {
    return $this->morphToMany('App\Tag','taggable');
  }
}

Post.php

namespace App;
use App\Photo;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
class Post extends Model
{
// get all the tags from this post.
public function tags()
{
  return $this->morphToMany('App\Tag','taggable');
}
}

Now we define the route.

use App\Post;
use App\Audio;
// Route for getting the tags from the Post model.
Route::get('/post/tags',function()
{
  $post=Post::find(1); 
  foreach($post->tags as $tag)
  {
    return $tag->name;
  }});
//Route for getting the tags from the Audio model.
Route::get('/audio/tags',function()
{
  $audio=Audio::find(1); 
  foreach($audio->tags as $tag)
  {
    return $tag->name;
  }});

Output

When accessing the route of the post, the output would be:

When accessing the route of the audio, the output would be:

Inverse of many-to-many (polymorphic) relationship

In a many-to-many polymorphic relationship, we found the tags belonging to the post and audio model. But, in an inverse relationship of many-to-many (polymorphic), we will find out all the posts and audios that belong to a particular tag.

Let's understand through an example.

First, we define the method in a Tag model.

Tag.php

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Tag extends Model
{
   // get all the posts from the tag. 
   public function posts()
    {
      return $this->morphedByMany('App\Post','taggable'); 
    }
// get all the audios from the tag.
public function audios()
    {
      return $this->morphedByMany('App\Audio','taggable'); 
    }
}

In the above code, we define two methods, posts() and audios(). In the posts() method, we are retrieving all the posts that belong to a specified tag. In the audios() method, we are retrieving all the audios that belong to a specified tag.

Now, we define the route.

use App\Tag;
// Route for getting all the posts of a tag.
Route::get('/tag/post/{id}',function($id){
$tag=Tag::find($id);
foreach($tag->posts as $post)
{
   return $post->title;
}
});
// Route for getting all the audios of a tag.
Route::get('/tag/audio/{id}',function($id){
$tag=Tag::find($id);
foreach($tag->audios as $audio)
{
   return $audio->name;
}
});

Output