{"id":3656,"date":"2020-12-22T04:15:50","date_gmt":"2020-12-22T04:15:50","guid":{"rendered":"https:\/\/studysection.com\/blog\/?p=3656"},"modified":"2020-12-22T04:41:05","modified_gmt":"2020-12-22T04:41:05","slug":"eloquent-relationships","status":"publish","type":"post","link":"https:\/\/studysection.com\/blog\/eloquent-relationships\/","title":{"rendered":"Eloquent: Relationships"},"content":{"rendered":"

Database tables are often related to one another. For example, a student in college could have several subjects, a bank account is related to the user who owns that. Eloquent makes managing and dealing with these relationships straight-forward and supports many different types of relationships:<\/p>\n

    \n
  1. One To One<\/li>\n
  2. One To Many<\/li>\n
  3. Many To Many D(2<\/li>\n
  4. Has One Through<\/li>\n
  5. Has Many Through<\/li>\n
  6. One To One (Polymorphic)<\/li>\n
  7. One To Many (Polymorphic)<\/li>\n
  8. Many To Many (Polymorphic)<\/li>\n<\/ol>\n

    One To One<\/h2>\n

    A one-to-one relationship is a very basic relation. For example, a person has only one car which belongs to its owner.
    \nExample: We have 2 models (OWNER<\/strong> and CAR<\/strong>) and two tables (owners<\/strong> and cars<\/strong>). Car belongs to one owner or the owner has only one car. <\/p>\n

    \"db1<\/p>\n

    The car table should have ownerID <\/strong>in it.
    \nEloquent Model:
    \nOwner Model:
    \nclass Owner
    \n{
    \n public function car()
    \n {
    \n return $this->hasOne(Car::class);
    \n }
    \n}
    \nCar model:
    \nclass Car
    \n{
    \n public function owner()
    \n {
    \n return $this->belongsTo(Owner::class);
    \n }
    \n}
    \nDatabase Migrations:
    \nOwner Schema:
    \nSchema::create('owners', function (Blueprint $table) {
    \n $table->increments('id');
    \n $table->string('name');
    \n});
    \nCars Schema :
    \nSchema::create('cars', function (Blueprint $table) {
    \n $table->increments('id');
    \n $table->string('name'); $table->integer('owner_id')->unsigned()->index()->nullable();
    \n $table->foreign('owner_id')->references('id')->on('owners');
    \n});<\/code><\/p>\n

    Additionally, eloquent assumes that the foreign key should have a worth value matching the id (or the custom $primaryKey) column of the parent. In alternative words, eloquent can seek for the value of the user’s id column within the user_id column of the Phone record. If you’d just like the relationship to use a price apart from id, you’ll pass the 3rd argument to the hasOne technique specifying your custom key:
    \nreturn $this->hasOne('App\\Car', 'foreign_key', 'local_key');<\/code>\t<\/p>\n

    One To Many<\/h3>\n

    A one-to-many relationship defines the relationships where a single model has any amount of other models.
    \nExample: We have 2 models (Thief<\/strong> and CAR<\/strong>) and two tables (thieves <\/strong>and cars<\/strong>). A thief can steal many cars or a car can be stolen by one thief.<\/p>\n

    \"db2<\/p>\n

    The Cars table should store the thiefId<\/strong>.
    \nEloquent Model:
    \nThief Model :
    \nclass Thief
    \n{
    \n public function cars()
    \n {
    \n return $this->hasMany(Car::class);
    \n }
    \n}
    \nCar model:
    \nclass Car
    \n{
    \n public function thief()
    \n {
    \n return $this->belongsTo(Thief::class);
    \n }
    \n}
    \nDatabase Migrations:
    \nThief Schema:
    \nSchema::create('thieves', function (Blueprint $table) {
    \n $table->increments('id');
    \n $table->string('name');
    \n});
    \nCars Schema:
    \nSchema::create('cars', function (Blueprint $table) {
    \n $table->increments('id');
    \n $table->string('name');
    \n $table->integer('thief_id')->unsigned()->index()->nullable();
    \n $table->foreign('thief_id')->references('id')->on('thieves');
    \n});<\/code>
    \nLike the hasOne<\/strong> method, you may also override the foreign <\/strong>and local keys<\/strong> by passing additional arguments to the hasMany<\/strong> method.<\/p>\n

    Many To Many<\/h3>\n

    Many-to-many relations are slightly more complicated than hasOne<\/strong> and hasMany <\/strong>relationships. An example of such a relationship is a user with many roles, where the roles are also shared by other users.
    \nExample: We have 2 models (Driver<\/strong> and Car<\/strong>), and 3 tables (drivers, cars and a pivot table named car_driver<\/strong>).<\/p>\n

    \"db3\"\/
    \nThe Pivot<\/strong> table \u201ccar_driver\u201d should store the driverId <\/strong>and the carId<\/strong>.
    \nEloquent Model:
    \nDriver Model:
    \nclass Driver
    \n{
    \n public function cars()
    \n {
    \n return $this->belongsToMany(Car::class);
    \n }
    \n}
    \nCar model:
    \nclass Car
    \n{
    \n public function thief()
    \n {
    \n return $this->belongsToMany(Driver::class);
    \n }
    \n}
    \nDatabase Migrations:
    \nDriver Schema:
    \nSchema::create('drivers', function (Blueprint $table) {
    \n $table->increments('id');
    \n $table->string('name');
    \n});
    \nCars Schema:
    \nSchema::create('cars', function (Blueprint $table) {
    \n $table->increments('id');
    \n $table->string('name');
    \n});
    \nPivot Schema:
    \nSchema::create('car_driver', function (Blueprint $table) {
    \n $table->increments('id');
    \n $table->integer('car_id')->unsigned()->index();
    \n $table->foreign('car_id')->references('id')->on('cars')->onDelete('cascade');
    \n $table->integer('driver_id')->unsigned()->index();
    \n $table->foreign('driver_id')->references('id')->on('drivers')->onDelete('cascade');
    \n});<\/code><\/p>\n

    One To Many (Polymorphic)<\/h3>\n

    A polymorphic relationship<\/strong> makes it possible for the target model that it can belong to one or more than one type of model using a single association. A one-to-many polymorphic<\/strong> relation is the same as that of simple one-to-one relation. However, the target model can belong to more than one type of model on a single association. For example, we have 3 models (Man, Woman, and Car) and 3 tables (men, women, and cars).<\/p>\n