Eloquent: Association

• Introduction
• Definition of Association
  • One to One
  • One-to-many
  • One-to-many (reverse)
  • Many-to-many
  • Customized intermediate table model
  • Remote one-to-one
  • Remote one-to-many
• Polymorphic association
  • One-to-one
  • One-to-many
  • Many-to-many
  • Custom polymorphic model
• Query association
  • Relationship method Vs. Dynamic attributes
  • Relationship query based on existence
  • Based on non-existence Related query
  • Related data count
• Preloading
  • is Preloading to add constraints
  • Lazy preloading
• ##Inserting & updating associated models
  • save Method
  • create Method
  • UpdateBelongs To Association
  • Many-to-many association
##Update parent set timestamp

Database tables are usually related to each other. For example, a blog post may have many comments, or an order may correspond to a user who placed the order. Eloquent makes it easy to manage and use these associations, and supports multiple types of associations:

##

Define Association

Eloquent Association is presented as a method in the Eloquent model class. Like the Eloquent model itself, associations can also be used as a powerful query statement builder, providing powerful chain calls and query functions. For example, we can attach a constraint to the chained call of the posts association:

$user->posts()->where('active', 1)->get();

But before we dive into using associations, let’s learn how to define each association type.

One-to-one

One-to-one is the most basic relationship. For example, a User model might be associated with a Phone model. In order to define this association, we need to write a phone method in the User model. Call the hasOne method inside the phone method and return its result:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class User extends Model{  
      /**
     * Get the phone record associated with the user.
     */   
      public function phone()   
       {       
            return $this->hasOne('App\Phone');  
         }
     }

hasOne The first parameter of the method is the class name of the associated model . Once the model association is defined, we can use Eloquent dynamic properties to obtain the related records. Dynamic properties allow you to access relational methods just like properties defined in the model:

$phone = User::find(1)->phone;

Eloquent will determine the foreign key name based on the model name. In this case, it is automatically assumed that the Phone model has a user_id foreign key. If you want to override this convention, you can pass a second argument to the hasOne method:

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

Additionally, Eloquent assumes that the value of the foreign key is the same as the parent id (or a custom $primaryKey) column values ​​match. In other words, Eloquent will look for a value in the user_id column of the Phone record that matches the id column of the Users table. If you want the association to use a custom key name other than id, you can pass the third parameter to the hasOne method:

return $this->hasOne('App\Phone', 'foreign_key', 'local_key');

Define the reverse association

We have The Phone model can be accessed from the User model. Now, let's define another association on the Phone model that will give us access to the User model that owns the phone. We can define a reverse association using the belongsTo method corresponding to the hasOne method:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Phone extends Model{  
      /**
     * 获得拥有此电话的用户
     */  
      public function user()  
        {      
          return $this->belongsTo('App\User'); 
         }
      }

In the above example, Eloquent will try to match Phone user_id on the model to id on the User model. It determines the default foreign key name by examining the name of the relationship method and using _id as the suffix. However, if the Phone model's foreign key is not user_id, then a custom key name can be passed as the second parameter to the belongsTo method:

/**
 * 获得拥有此电话的用户
 */
 public function user(){ 
    return $this->belongsTo('App\User', 'foreign_key');
   }

If the parent model does not use id as the primary key, or if you want to use different fields to connect the child model, you can pass the third parameter to the belongsTo method. Specify the custom key of the parent data table in the form:

/**
 * 获得拥有此电话的用户
 */
 public function user(){ 
    return $this->belongsTo('App\User', 'foreign_key', 'other_key');
  }

One-to-many

The "one-to-many" association is used to define a single model to have any number of other associated models. For example, a blog post may have an infinite number of comments. Like all other Eloquent relationships, the definition of a one-to-many relationship is to write a method in the Eloquent model:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Post extends Model{  
      /**
     * 获取博客文章的评论
     */  
      public function comments()   
       {     
          return $this->hasMany('App\Comment');  
       }
  }

Remember, Eloquent will automatically determine the foreign key of the Comment model Attributes. By convention, Eloquent will use the "snake case" form of the model name, plus the _id suffix as the foreign key field. Therefore, in the above example, Eloquent will assume that the foreign key on the Comment corresponding to the Post model is post_id.

Once the relationship is defined, the collection of comments can be obtained by accessing the comments property of the Post model. Remember, since Eloquent provides "dynamic properties", we can access the relationship method just like accessing the model's properties:

$comments = App\Post::find(1)->comments;foreach ($comments as $comment) {    //}

Of course, since all relationships can also be used as query statement builders, you can Use chained calls to add additional constraints on the comments method:

$comment = App\Post::find(1)->comments()->where('title', 'foo')->first();

Just like the hasOne method, you can also use hasMany method, pass additional parameters to override the default foreign keys and local keys used:

return $this->hasMany('App\Comment', 'foreign_key');
return $this->hasMany('App\Comment', 'foreign_key', 'local_key');

One-to-many (Reverse)

Now, we have been able to obtain all the comments of an article, and then define an association to obtain the article through the comments. This association is the reverse association of the hasMany association. It needs to be defined in the child model using the belongsTo method:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Comment extends Model{ 
    /**
     * 获取此评论所属文章
     */   
     public function post()   
      {      
        return $this->belongsTo('App\Post');   
       }
   }

After this relationship is defined, we can Get the associated Post model by accessing the post "dynamic attribute" of the Comment model:

$comment = App\Comment::find(1);
echo $comment->post->title;

In the above example, Eloquent will try to match the post_id of the Comment model with the id of the Post model. The default foreign key name is determined by Eloquent based on the association name, followed by _ and the primary key field name as a suffix. Of course, if the foreign key of the Comment model is not post_id, then the custom key name can be passed as the second parameter to the belongsTo method:

/**
 * 获取此评论所属文章
 */
 public function post(){
     return $this->belongsTo('App\Post', 'foreign_key');
   }

If the parent model does not use id as the primary key, or if you want to use different fields to connect the child model, you can pass the third parameter to the belongsTo method. Specify the custom key of the parent data table in the form:

/**
 * 获取此评论所属文章
 */
 public function post(){ 
    return $this->belongsTo('App\Post', 'foreign_key', 'other_key');
  }

Many-to-Many

Many-to-many relationships are slightly more complex than hasOne and hasMany relationships. For example, a user can have many roles, and these roles are shared by other users. For example, many users may have the "Administrator" role. To define this association, three database tables are required: users, roles, and role_user. The role_user table is named in alphabetical order from the two associated models, and contains the user_id and role_id fields.

Many-to-many relationships are defined by calling the result returned by this internal method belongsToMany. For example, we define the roles method in the User model. :

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;class User extends Model{  
      /**
     * 用户拥有的角色
     */   
      public function roles()   
       {      
         return $this->belongsToMany('App\Role');  
        }
     }

Once the association is defined, you can obtain the user role through the roles dynamic attribute:

$user = App\User::find(1);
foreach ($user->roles as $role) {  
  //
}

Of course, like all other association models, you can use roles method, using chain calls to add constraints to the query statement:

$roles = App\User::find(1)->roles()->orderBy('name')->get();

As mentioned earlier, in order to determine the table name of the associated connection table, Eloquent will connect the two in alphabetical order The name of an associated model. Of course, you can also not use this convention and pass the second parameter to the belongsToMany method:

return $this->belongsToMany('App\Role', 'role_user');

In addition to customizing the table name of the connection table, you can also pass additional Parameters to the belongsToMany method to define the key names of the fields in the table. The third parameter is the foreign key name of the model that defines this association in the connection table, and the fourth parameter is the foreign key name of another model in the connection table:

return $this->belongsToMany('App\Role', 'role_user', 'user_id', 'role_id');

Definition Reverse association

To define a many-to-many reverse association, you only need to call the belongsToMany method in the association model. We define the users method in the Role model:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Role extends Model{    
    /**
     * 拥有此角色的用户。
     */   
      public function users()   
       {      
         return $this->belongsToMany('App\User');  
        }
      }

As you can see, except for the introduction of the model App\User, other Exactly the same as defined in the User model. Since we reuse the belongsToMany method, the custom join table table name and the field name of the key in the custom join table are also applicable here.

Get the intermediate table fields

As you just learned, the many-to-many relationship requires an intermediate table to provide support. Eloquent provides some useful methods to interact with this table. . For example, suppose our User object is associated with multiple Role objects. After obtaining these related objects, you can use the pivot attribute of the model to access the data of the intermediate table:

$user = App\User::find(1);
foreach ($user->roles as $role) { 
   echo $role->pivot->created_at;
  }

It should be noted that each Role model we obtain Object will be automatically assigned the pivot attribute, which represents a model object of the intermediate table and can be used like other Eloquent models.

By default, the pivot object only contains the primary keys of the two related models. If there are other additional fields in your intermediate table, you must explicitly indicate it when defining the relationship:

return $this->belongsToMany('App\Role')->withPivot('column1', 'column2');

If you want the intermediate table to automatically maintain created_at and updated_at timestamps, then append the withTimestamps method when defining the association:

return $this->belongsToMany('App\Role')->withTimestamps();

Custompivot Attribute name

As mentioned earlier, attributes from the intermediate table can be accessed using the pivot attribute . However, you are free to customize the name of this property to better reflect its use in your application.

For example, if your app contains users who may subscribe, there may be a many-to-many relationship between users and blogs. If this is the case, you may want to name the intermediate table accessor subscription instead of pivot. This can be done using the as method when defining the relationship:

return $this->belongsToMany('App\Podcast')           
     ->as('subscription')                
     ->withTimestamps();

Once the definition is complete, you can access the intermediate table data using a custom name:

$users = User::with('podcasts')->get();
foreach ($users->flatMap->podcasts as $podcast) { 
   echo $podcast->subscription->created_at;
 }

Filter relationships through intermediate tables

When defining relationships, you can also use the wherePivot and wherePivotIn methods to filter the results returned by belongsToMany :

return $this->belongsToMany('App\Role')->wherePivot('approved', 1);
return $this->belongsToMany('App\Role')->wherePivotIn('priority', [1, 2]);

Define the intermediate table model

Define the custom intermediate table model
If you want to define a custom model to represent the intermediate table in the association relationship, you can call using# when defining the association. ## method. CustomizedMany-to-manyIntermediate table models must extend from the Illuminate\Database\Eloquent\Relations\Pivot class, customMany-to-many (polymorphic)Intermediate table models must inherit Illuminate \Database\Eloquent\Relations\MorphPivot class. For example, When we write the association of the Role model, we use a custom intermediate table model
UserRole

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Role extends Model{   
     /**
     * 拥有此角色的所有用户
     */   
     public function users() 
        {   
             return $this->belongsToMany('App\User')->using('App\UserRole'); 
        }
   }

UserRole model, we need to extendPivot Class:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Relations\Pivot;
    class UserRole extends Pivot{   
     //
  }

using and withPivot to retrieve columns from an intermediate table. For example, by passing the column name to the withPivot method, you can retrieve the created_by and updated_by columns from the UserRole intermediate table .

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Role extends Model{   
     /**
     * 拥有此角色的用户。
     */  
       public function users()  
         {     
            return $this->belongsToMany('App\User')                   
                 ->using('App\UserRole')                        
                 ->withPivot([                         
                    'created_by',                            
                    'updated_by'                      
                    ]);  
            }
       }

incrementing attribute with a value of true:

/**
 * 标识 ID 是否自增。
 *
 * @var bool
 */
 public $incrementing = true;

For example, if each provider has a user, and each user is associated with a user history, then the provider can access the user's history through the user, let's look at the database required to define this relationship Table:

suppliers
    id - integer
users
    id - integer
    supplier_id - integer

history
    id - integer
    user_id - integer

history table does not contain the supplier_id, the hasOneThrough relationship can provide access to the user's history to access the supplier Model. Now that we have inspected the table structure of the relationship, let us define the corresponding method on the Supplier model:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Supplier extends Model{   
     /**
     * 用户的历史记录。
     */  
       public function userHistory()  
         {      
           return $this->hasOneThrough('App\History', 'App\User');  
          }
       }

hasOneThrough method is The name of the model you wish to access. The second parameter is the name of the intermediate model.

hasOneThrough method. The third parameter represents the foreign key name of the intermediate model, and the fourth parameter represents the final The foreign key name of the model. The fifth parameter represents the local key name, and the sixth parameter represents the local key name of the intermediate model:

class Supplier extends Model{  
  /**
     * 用户的历史记录。
     */   
     public function userHistory()   
      {     
         return $this->hasOneThrough(         
            'App\History',            
            'App\User',            
            'supplier_id', // 用户表外键            
             'user_id', // 历史记录表外键            
             'id', // 供应商本地键            
             'id' // 用户本地键     
              );   
          }
      }

countries
    id - integer
    name - string

users
    id - integer
    country_id - integer
    name - string

posts
    id - integer
    user_id - integer
    title - string

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Country extends Model{   
     /**
     * 当前国家所有文章。
     */   
      public function posts()  
        {    
            return $this->hasManyThrough('App\Post', 'App\User'); 
         }
     }

class Country extends Model{ 
   public function posts()   
    {     
       return $this->hasManyThrough(        
           'App\Post',            
           'App\User',            
           'country_id', // 用户表外键            
           'user_id', // 文章表外键            
           'id', // 国家表本地键            
           'id' // 用户表本地键      
           );  
      }
  }

posts
    id - integer
    name - string

users
    id - integer
    name - string

images
    id - integer
    url - string
    imageable_id - integer
    imageable_type - string

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Image extends Model{   
     /**
     * 获取拥有此图片的模型。
     */    
     public function imageable()  
       {     
          return $this->morphTo();  
        }
       }
     class Post extends Model{  
    /**
     * 获取文章图片。
     */    
     public function image()  
       {       
        return $this->morphOne('App\Image', 'imageable');   
        }
      }
   class User extends Model{   
    /**
     * 获取用户图片。
     */   
     public function image()   
     {     
       return $this->morphOne('App\Image', 'imageable'); 
     }
    }

$post = App\Post::find(1);
$image = $post->image;

$image = App\Image::find(1);
$imageable = $image->imageable;

posts
    id - integer
    title - string
    body - text

videos
    id - integer
    title - string
    url - string

comments
    id - integer
    body - text
    commentable_id - integer
    commentable_type - string

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Comment extends Model{   
     /**
     * 获取拥有此评论的模型。
     */   
      public function commentable() 
         {      
           return $this->morphTo();   
         }
      }
    class Post extends Model{   
    /**
     * 获取此文章的所有评论。
     */  
      public function comments()  
        {    
            return $this->morphMany('App\Comment', 'commentable');  
          }
       }
     class Video extends Model{  
    /**
     * 获取此视频的所有评论。
     */   
     public function comments()  
       {    
           return $this->morphMany('App\Comment', 'commentable');  
       }
    }

$post = App\Post::find(1);foreach ($post->comments as $comment) {
    //
  }

$comment = App\Comment::find(1);
$commentable = $comment->commentable;

posts
    id - integer
    name - string

videos
    id - integer
    name - string

tags
    id - integer
    name - string

taggables
    tag_id - integer
    taggable_id - integer
    taggable_type - string

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Post extends Model{   
     /**
     * 获取文章的所有标签。
     */   
      public function tags()  
        {     
           return $this->morphToMany('App\Tag', 'taggable');  
         }
      }

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Tag extends Model{ 
     /**
     * 获取被打上此标签的所有文章。
     */   
      public function posts() 
         {    
             return $this->morphedByMany('App\Post', 'taggable');  
          }   
     /**
     * 获取被打上此标签的所有视频。
     */   
      public function videos()  
        {       
         return $this->morphedByMany('App\Video', 'taggable');  
         }
     }

$post = App\Post::find(1);foreach ($post->tags as $tag) { 
   //
}

$tag = App\Tag::find(1);foreach ($tag->videos as $video) {
    //
 }

use Illuminate\Database\Eloquent\Relations\Relation;
Relation::morphMap([ 
   'posts' => 'App\Post',    
   'videos' => 'App\Video',
 ]);

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class User extends Model{    
    /**
     * 获取该用户的所有文章。
     */  
     public function posts()  
       {     
          return $this->hasMany('App\Post');   
        }
    }

$user = App\User::find(1);
$user->posts()->where('active', 1)->get();

$user = App\User::find(1);
foreach ($user->posts as $post) {
    //
  }

// 获取至少存在一条评论的所有文章...
$posts = App\Post::has('comments')->get();

// 获取评论超过三条的文章...
$posts = App\Post::has('comments', '>=', 3)->get();

// 获取拥有至少一条带有投票评论的文章...
$posts = App\Post::has('comments.votes')->get();

use Illuminate\Database\Eloquent\Builder;
// 获取至少带有一条评论内容包含 foo% 关键词的文章...
$posts = App\Post::whereHas('comments', function ($query)
 { 
    $query->where('content', 'like', 'foo%');})->get();
    // 获取至少带有十条评论内容包含 foo% 关键词的文章...
    $posts = App\Post::whereHas('comments', function ($query)
     { 
        $query->where('content', 'like', 'foo%');
      }, '>=', 10)->get();

$posts = App\Post::doesntHave('comments')->get();

use Illuminate\Database\Eloquent\Builder;
$posts = App\Post::whereDoesntHave('comments', function (Builder $query)
 {  
   $query->where('content', 'like', 'foo%');
 })->get();

use Illuminate\Database\Eloquent\Builder;
$posts = App\Post::whereDoesntHave('comments.author', function (Builder $query) 
{   
 $query->where('banned', 1);
})->get();

$posts = App\Post::withCount('comments')->get();
foreach ($posts as $post) {
    echo $post->comments_count;
   }

$posts = App\Post::withCount(['votes', 'comments' => function ($query)
 { 
    $query->where('content', 'like', 'foo%');
  }])->get();
    echo $posts[0]->votes_count;echo $posts[0]->comments_count;

$posts = App\Post::withCount([
    'comments',    
    'comments as pending_comments_count' => function ($query) { 
           $query->where('approved', false);   
      }])->get();
   echo $posts[0]->comments_count;
    echo $posts[0]->pending_comments_count;

$query = App\Post::select(['title', 'body'])->withCount('comments');
echo $posts[0]->title;
echo $posts[0]->body;
echo $posts[0]->comments_count;

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Book extends Model{  
      /**
     * 获取书籍作者。
     */ 
      public function author() 
         {    
             return $this->belongsTo('App\Author');   
          }
       }

$books = App\Book::all();
foreach ($books as $book) 
{ 
   echo $book->author->name;
}

$books = App\Book::with('author')->get();
foreach ($books as $book) {
    echo $book->author->name;
  }

select * from books
select * from authors where id in (1, 2, 3, 4, 5, ...)

$books = App\Book::with(['author', 'publisher'])->get();

$books = App\Book::with('author.contacts')->get();

$users = App\Book::with('author:id,name')->get();

$users = App\User::with(['posts' => function ($query) { 
   $query->where('title', 'like', '%first%');
  }])->get();

$users = App\User::with(['posts' => function ($query) {
    $query->orderBy('created_at', 'desc');
  }])->get();

$books = App\Book::all();
if ($someCondition) {
    $books->load('author', 'publisher');
  }

$books->load(['author' => function ($query) {
    $query->orderBy('published_date', 'asc');
   }]);

public function format(Book $book){
    $book->loadMissing('author');    
    return [    
        'name' => $book->name,        
        'author' => $book->author->name   
       ];
   }

<?php
    use Illuminate\Database\Eloquent\Model;
    class ActivityFeed extends Model{   
     /**
     * Get the parent of the activity feed record.
     */   
   public function parentable() 
      {    
          return $this->morphTo(); 
       }
    }

$activities = ActivityFeed::with('parentable')
    ->get()    
    ->loadMorph('parentable', [ 
           Event::class => ['calendar'],        
           Photo::class => ['tags'],        
           Post::class => ['author'],   
          ]);

$comment = new App\Comment(['message' => 'A new comment.']);
$post = App\Post::find(1);
$post->comments()->save($comment);

$post = App\Post::find(1);
$post->comments()->saveMany([ 
   new App\Comment(['message' => 'A new comment.']),    
   new App\Comment(['message' => 'Another comment.']),
 ]);

$post = App\Post::find(1);
$post->comments[0]->message = 'Message';
$post->comments[0]->author->name = 'Author Name';$post->push();

$post = App\Post::find(1);
$comment = $post->comments()->create([
    'message' => 'A new comment.',
  ]);

$post = App\Post::find(1);$post->comments()->createMany([
    [  
          'message' => 'A new comment.',  
     ],    
     [    
           'message' => 'Another new comment.',  
     ],
  ]);

$account = App\Account::find(10);
$user->account()->associate($account);$user->save();

$user->account()->dissociate();$user->save();

/**
 * 获取帖子的作者。
 */
 public function user(){
     return $this->belongsTo('App\User')->withDefault();
   }

/**
 * 获取帖子的作者。
 */
 public function user(){
     return $this->belongsTo('App\User')->withDefault([ 
            'name' => 'Guest Author', 
          ]);
       }
 /**
 * 获取帖子的作者。
 */
 public function user(){
     return $this->belongsTo('App\User')->withDefault(function ($user) {
             $user->name = 'Guest Author'; 
            });
        }

$user = App\User::find(1);
$user->roles()->attach($roleId);

$user->roles()->attach($roleId, ['expires' => $expires]);

// 移除用户的一个角色...
$user->roles()->detach($roleId);
// 移除用户的所有角色...
$user->roles()->detach();

$user = App\User::find(1);
$user->roles()->detach([1, 2, 3]);
$user->roles()->attach([
    1 => ['expires' => $expires],    
    2 => ['expires' => $expires]
  ]);

$user->roles()->sync([1, 2, 3]);

$user->roles()->sync([1 => ['expires' => true], 2, 3]);

$user->roles()->syncWithoutDetaching([1, 2, 3]);

$user->roles()->toggle([1, 2, 3]);

App\User::find(1)->roles()->save($role, ['expires' => $expires]);

$user = App\User::find(1);
$user->roles()->updateExistingPivot($roleId, $attributes);

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class Comment extends Model{ 
       /**
     * 要触发的所有关联关系
     *
     * @var array
     */  
      protected $touches = ['post'];   
     /**
     * 评论所属的文章
     */   
     public function post() 
        {     
           return $this->belongsTo('App\Post');  
         }
      }

$comment = App\Comment::find(1);
$comment->text = 'Edit to this comment!';
$comment->save();