イントロダクションIntroduction
データベーステーブルは大抵の場合、他と関連しています。たとえばブログ投稿(ポスト)は多くのコメントを持つか、それを投稿したユーザーと関連しています。Eloquentはそうしたリレーションを簡単に管理し操作できるようにするとともに、さまざまなタイプのリレーションをサポートしています。Database tables are often related to one another. For example, a blog post may have many comments, or an order could be related to the user who placed it. Eloquent makes managing and working with these relationships easy, and supports several different types of relationships:
リレーションの定義Defining Relationships
Eloquentのリレーション(関係)は、Eloquentモデルクラスのメソッドとして定義します。Eloquentモデル自身と同様にリレーションはパワフルなクエリビルダとして動作しますので、メソッドとして定義しているリレーションはパワフルなメソッドのチェーンとクエリ能力を提供できるのです。例として、posts関係に追加の制約をチェーンしてみましょう。Eloquent relationships are defined as methods on your Eloquent model classes. Since, like Eloquent models themselves, relationships also serve as powerful query builders[/docs/{{version}}/queries], defining relationships as methods provides powerful method chaining and querying capabilities. For example, we may chain additional constraints on this posts
relationship:
$user->posts()->where('active', 1)->get();
リレーションの詳しい使い方へ進む前に、リレーションの各タイプをどのように定義するかを学びましょう。But, before diving too deep into using relationships, let's learn how to define each type.
Note: {note} Relationship names cannot collide with attribute names as that could lead to your model not being able to know which one to resolve.
モデルがどの属性を解決すればよいのかわからなくなる可能性があるため、リレーション名は属性名と一緒にはできません。
1対1One To One
1対1関係が基本です。たとえばUser
モデルはPhone
モデル一つと関係しているとしましょう。このリレーションを定義するには、phone
メソッドをUser
モデルに設置します。phone
メソッドはベースのEloquentモデルクラスのhasOne
メソッドを結果として返す必要があります。A one-to-one relationship is a very basic relation. For example, a User
model might be associated with one Phone
. To define this relationship, we place a phone
method on the User
model. The phone
method should call the hasOne
method and return its result:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{
/**
* ユーザーに関連する電話レコードを取得
*/
public function phone()
{
return $this->hasOne('App\Phone');
}
}
hasOne
メソッドの最初の引数は関係するモデルの名前です。リレーションが定義できたらEloquentの動的プロパティを使って、関係したレコードを取得できます。動的プロパティによりモデル上のプロパティのようにリレーションメソッドにアクセスできます。The first argument passed to the hasOne
method is the name of the related model. Once the relationship is defined, we may retrieve the related record using Eloquent's dynamic properties. Dynamic properties allow you to access relationship methods as if they were properties defined on the model:
$phone = User::find(1)->phone;
Eloquentはリレーションの外部キーがモデル名に基づいていると仮定します。この場合自動的にPhone
モデルはuser_id
外部キーを持っていると仮定します。この規約をオーバーライドしたければ、hasOne
メソッドの第2引数を指定してください。Eloquent determines the foreign key of the relationship based on the model name. In this case, the Phone
model is automatically assumed to have a user_id
foreign key. If you wish to override this convention, you may pass a second argument to the hasOne
method:
return $this->hasOne('App\Phone', 'foreign_key');
Eloquentは親のid
カラム(もしくはカスタム$primaryKey
)と一致する外部キーの値を持っていると仮定します。言い換えればEloquentはユーザーのid
カラムの値をPhone
レコードのuser_id
カラムに存在しないか探します。リレーションで他のid
を使いたければ、hadOne
メソッドの第3引数でカスタムキーを指定してください。Additionally, Eloquent assumes that the foreign key should have a value matching the id
(or the custom $primaryKey
) column of the parent. In other words, Eloquent will look for the value of the user's id
column in the user_id
column of the Phone
record. If you would like the relationship to use a value other than id
, you may pass a third argument to the hasOne
method specifying your custom key:
return $this->hasOne('App\Phone', 'foreign_key', 'local_key');
逆の関係の定義Defining The Inverse Of The Relationship
これでUser
からPhone
モデルへアクセスできるようになりました。今度はPhone
モデルからそれを所有しているUser
へアクセスするリレーションを定義しましょう。hasOne
の逆のリレーションを定義するには、belongsTo
メソッドを使います。So, we can access the Phone
model from our User
. Now, let's define a relationship on the Phone
model that will let us access the User
that owns the phone. We can define the inverse of a hasOne
relationship using the belongsTo
method:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Phone extends Model
{
/**
* この電話を所有するUserを取得
*/
public function user()
{
return $this->belongsTo('App\User');
}
}
上の例でEloquentはPhone
モデルのuser_id
に一致するid
を持つUser
モデルを見つけようとします。Eloquentはリレーションメソッド名に_id
のサフィックスを付けた名前をデフォルトの外部キー名とします。しかしPhone
モデルの外部キーがuser_id
でなければ、belongsTo
メソッドの第2引数にカスタムキー名を渡してください。In the example above, Eloquent will try to match the user_id
from the Phone
model to an id
on the User
model. Eloquent determines the default foreign key name by examining the name of the relationship method and suffixing the method name with _id
. However, if the foreign key on the Phone
model is not user_id
, you may pass a custom key name as the second argument to the belongsTo
method:
/**
* この電話を所有するUserを取得
*/
public function user()
{
return $this->belongsTo('App\User', 'foreign_key');
}
親のモデルの主キーがid
でない、もしくは子のモデルと違ったカラムで紐付けたい場合は、親テーブルのカスタムキー名をbelongsTo
メソッドの第3引数に渡してください。If your parent model does not use id
as its primary key, or you wish to join the child model to a different column, you may pass a third argument to the belongsTo
method specifying your parent table's custom key:
/**
* この電話を所有するUserを取得
*/
public function user()
{
return $this->belongsTo('App\User', 'foreign_key', 'other_key');
}
1対多One To Many
1対多リレーションは一つのモデルが他の多くのモデルを所有する関係を定義するために使います。ブログポストが多くのコメントを持つのが一例です。他のEloquentリレーションと同様に1対多リレーションはEloquentモデルの関数として定義します。A one-to-many relationship is used to define relationships where a single model owns any amount of other models. For example, a blog post may have an infinite number of comments. Like all other Eloquent relationships, one-to-many relationships are defined by placing a function on your Eloquent model:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Post extends Model
{
/**
* ブログポストのコメントを取得
*/
public function comments()
{
return $this->hasMany('App\Comment');
}
}
Eloquentは、Comment
モデルに対する外部キーを自動的に決めることを心に留めてください。規約によりEloquentは、自分自身のモデル名の「スネークケース」に_id
のサフィックスをつけた名前と想定します。ですから今回の例でEloquentは、Comment
モデルの外部キーをpost_id
であると想定します。Remember, Eloquent will automatically determine the proper foreign key column on the Comment
model. By convention, Eloquent will take the "snake case" name of the owning model and suffix it with _id
. So, for this example, Eloquent will assume the foreign key on the Comment
model is post_id
.
リレーションを定義したら、comments
プロパティによりコメントのコレクションへアクセスできます。Eloquentは「動的プロパティ」を提供しているので、モデルのプロパティとして定義したリレーションメソッドへアクセスできることを覚えておきましょう。Once the relationship has been defined, we can access the collection of comments by accessing the comments
property. Remember, since Eloquent provides "dynamic properties", we can access relationship methods as if they were defined as properties on the model:
$comments = App\Post::find(1)->comments;
foreach ($comments as $comment) {
//
}
全リレーションはクエリビルダとしても働きますから、comments
メソッドを呼び出すときにどのコメントを取得するのかという制約を追加でき、クエリに条件を続けてチェーンでつなげます。Since all relationships also serve as query builders, you can add further constraints to which comments are retrieved by calling the comments
method and continuing to chain conditions onto the query:
$comment = App\Post::find(1)->comments()->where('title', 'foo')->first();
hasOne
メソッドと同様に、外部キーとローカルキーをhasMany
メソッドに追加の引数として渡すことでオーバーライドできます。Like the hasOne
method, you may also override the foreign and local keys by passing additional arguments to the hasMany
method:
return $this->hasMany('App\Comment', 'foreign_key');
return $this->hasMany('App\Comment', 'foreign_key', 'local_key');
1対多 (Inverse)One To Many (Inverse)
これでポストの全コメントにアクセスできます。今度はコメントから親のポストへアクセスできるようにしましょう。hasMany
リレーションの逆を定義するには子のモデルでbelongsTo
メソッドによりリレーション関数を定義します。Now that we can access all of a post's comments, let's define a relationship to allow a comment to access its parent post. To define the inverse of a hasMany
relationship, define a relationship function on the child model which calls the belongsTo
method:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Comment extends Model
{
/**
* このコメントを所有するポストを取得
*/
public function post()
{
return $this->belongsTo('App\Post');
}
}
リレーションが定義できたらComment
のPost
モデルをpost
動的プロパティにより取得しましょう。Once the relationship has been defined, we can retrieve the Post
model for a Comment
by accessing the post
"dynamic property":
$comment = App\Comment::find(1);
echo $comment->post->title;
前の例でEloquentはComment
モデルのpost_id
と一致するid
のPost
モデルを見つけようとします。Eloquentはリレーションメソッドの名前として、_
に続けて主キーのカラム名をサフィックスとして付けた名前をデフォルトの外部キーとします。しかしComment
モデルの外部キーがpost_id
でなければ、belongsTo
メソッドの第2引数にカスタムキー名を指定してください。In the example above, Eloquent will try to match the post_id
from the Comment
model to an id
on the Post
model. Eloquent determines the default foreign key name by examining the name of the relationship method and suffixing the method name with a _
followed by the name of the primary key column. However, if the foreign key on the Comment
model is not post_id
, you may pass a custom key name as the second argument to the belongsTo
method:
/**
* このコメントを所有するポストを取得
*/
public function post()
{
return $this->belongsTo('App\Post', 'foreign_key');
}
親のモデルの主キーがid
でない、もしくは子のモデルと違ったカラムで紐付けたい場合は、親テーブルのカスタムキー名をbelongsTo
メソッドの第3引数に渡してください。If your parent model does not use id
as its primary key, or you wish to join the child model to a different column, you may pass a third argument to the belongsTo
method specifying your parent table's custom key:
/**
* このコメントを所有するポストを取得
*/
public function post()
{
return $this->belongsTo('App\Post', 'foreign_key', 'other_key');
}
多対多Many To Many
多対多の関係はhasOne
とhasMany
リレーションよりも多少複雑な関係です。このような関係として、ユーザー(user)が多くの役目(roles)を持ち、役目(role)も大勢のユーザー(users)に共有されるという例が挙げられます。たとえば多くのユーザーは"管理者"の役目を持っています。Many-to-many relations are slightly more complicated than hasOne
and hasMany
relationships. An example of such a relationship is a user with many roles, where the roles are also shared by other users. For example, many users may have the role of "Admin".
テーブル構造Table Structure
この関係を定義するには、users
、roles
、role_user
の3テーブルが必要です。role_user
テーブルは関係するモデル名をアルファベット順に並べたもので、user_id
とrole_id
を持つ必要があります。To define this relationship, three database tables are needed: users
, roles
, and role_user
. The role_user
table is derived from the alphabetical order of the related model names, and contains the user_id
and role_id
columns:
users
id - integer
name - string
roles
id - integer
name - string
role_user
user_id - integer
role_id - integer
モデル構造Model Structure
多対多リレーションはbelongsToMany
メソッド呼び出しを記述することで定義します。例としてUser
モデルにroles
メソッドを定義してみましょう。Many-to-many relationships are defined by writing a method that returns the result of the belongsToMany
method. For example, let's define the roles
method on our User
model:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{
/**
* userに所属する役目を取得
*/
public function roles()
{
return $this->belongsToMany('App\Role');
}
}
リレーションが定義できたら、roles
動的プロパティを使いユーザーの役割にアクセスできます。Once the relationship is defined, you may access the user's roles using the roles
dynamic property:
$user = App\User::find(1);
foreach ($user->roles as $role) {
//
}
他のリレーションタイプと同様にリレーションを制約するクエリをroles
に続けてチェーンできます。Like all other relationship types, you may call the roles
method to continue chaining query constraints onto the relationship:
$roles = App\User::find(1)->roles()->orderBy('name')->get();
前に述べたようにリレーションの結合テーブルの名前を決めるため、Eloquentは2つのモデル名をアルファベット順に結合します。しかしこの規約は自由にオーバーライドできます。belongsToMany
メソッドの第2引数に渡してください。As mentioned previously, to determine the table name of the relationship's joining table, Eloquent will join the two related model names in alphabetical order. However, you are free to override this convention. You may do so by passing a second argument to the belongsToMany
method:
return $this->belongsToMany('App\Role', 'role_user');
結合テーブル名のカスタマイズに加えテーブルのキーカラム名をカスタマイズするには、belongsToMany
メソッドに追加の引数を渡してください。第3引数はリレーションを定義しているモデルの外部キー名で、一方の第4引数には結合するモデルの外部キー名を渡します。In addition to customizing the name of the joining table, you may also customize the column names of the keys on the table by passing additional arguments to the belongsToMany
method. 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 to:
return $this->belongsToMany('App\Role', 'role_user', 'user_id', 'role_id');
逆の関係の定義Defining The Inverse Of The Relationship
多対多のリレーションの逆リレーションを定義するには、関連するモデルでbelongsToMany
を呼び出してください。引き続きユーザーと役割の例を続けますがRole
モデルでusers
メソッドを定義してみましょう。To define the inverse of a many-to-many relationship, you place another call to belongsToMany
on your related model. To continue our user roles example, let's define the users
method on the Role
model:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Role extends Model
{
/**
* 役目を所有するユーザー
*/
public function users()
{
return $this->belongsToMany('App\User');
}
}
ご覧の通り一方のUser
とまったく同じ定義のリレーションです。違いはApp\User
モデルを参照していることです。同じbelongsToMany
メソッドを使っているのですから、通常のテーブル名、キーカスタマイズのオプションは逆の多対多リレーションを定義するときでもすべて使用できます。As you can see, the relationship is defined exactly the same as its User
counterpart, with the exception of referencing the App\User
model. Since we're reusing the belongsToMany
method, all of the usual table and key customization options are available when defining the inverse of many-to-many relationships.
中間テーブルのカラム取得Retrieving Intermediate Table Columns
すでに学んだように、多対多リレーションの操作には中間テーブルが必要です。Eloquentこのテーブルを操作する便利な手段を用意しています。例としてUser
オブジェクトが関連するRole
オブジェクトを持っているとしましょう。このリレーションへアクセスした後、モデルのpivot
属性を使い中間テーブルにアクセスできます。As you have already learned, working with many-to-many relations requires the presence of an intermediate table. Eloquent provides some very helpful ways of interacting with this table. For example, let's assume our User
object has many Role
objects that it is related to. After accessing this relationship, we may access the intermediate table using the pivot
attribute on the models:
$user = App\User::find(1);
foreach ($user->roles as $role) {
echo $role->pivot->created_at;
}
取得したそれぞれのRole
モデルはpivot
属性と自動的に結合されます。この属性は中間テーブルを表すモデルを含んでおり、他のElouquentモデルと同様に使用できます。Notice that each Role
model we retrieve is automatically assigned a pivot
attribute. This attribute contains a model representing the intermediate table, and may be used like any other Eloquent model.
デフォルトでモデルキーはpivot
オブジェクト上のものを表しています。中間テーブルがその他の属性を持っている場合、リレーションを定義するときに指定できます。By default, only the model keys will be present on the pivot
object. If your pivot table contains extra attributes, you must specify them when defining the relationship:
return $this->belongsToMany('App\Role')->withPivot('column1', 'column2');
もし中間テーブルのcreated_at
、updated_at
タイムスタンプを自動的に保守したい場合は、withTimestamps
メソッドをリレーション定義に付けてください。If you want your pivot table to have automatically maintained created_at
and updated_at
timestamps, use the withTimestamps
method on the relationship definition:
return $this->belongsToMany('App\Role')->withTimestamps();
pivot
属性の名前変更Customizing The pivot
Attribute Name
前述の通り、中間テーブルにはpivot
属性を使ってアクセスできます。その際、アプリケーションの目的をより良く反映するためにpivot
属性の名前を変更できます。As noted earlier, attributes from the intermediate table may be accessed on models using the pivot
attribute. However, you are free to customize the name of this attribute to better reflect its purpose within your application.
たとえばユーザーがポッドキャストを購読するようなアプリケーションでは、ユーザーとポッドキャストが多対多の関係となっていることがあります。その場合、中間テーブルへアクセスする際のpivot
属性の名前をsubscription
に変更したいかもしれません。これはリレーションを定義する際に、as
メソッドを使うことで実現できます。For example, if your application contains users that may subscribe to podcasts, you probably have a many-to-many relationship between users and podcasts. If this is the case, you may wish to rename your intermediate table accessor to 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 this is done, you may access the intermediate table data using the customized name:
$users = User::with('podcasts')->get();
foreach ($users->flatMap->podcasts as $podcast) {
echo $podcast->subscription->created_at;
}
中間テーブルのカラムを使った関係のフィルタリングFiltering Relationships Via Intermediate Table Columns
リレーション定義時に、wherePivot
やwherePivotIn
、wherePivotNotIn
を使い、belongsToMany
が返す結果をフィルタリングすることも可能です。You can also filter the results returned by belongsToMany
using the wherePivot
, wherePivotIn
, and wherePivotNotIn
methods when defining the relationship:
return $this->belongsToMany('App\Role')->wherePivot('approved', 1);
return $this->belongsToMany('App\Role')->wherePivotIn('priority', [1, 2]);
return $this->belongsToMany('App\Role')->wherePivotNotIn('priority', [1, 2]);
カスタム中間テーブルモデルの定義Defining Custom Intermediate Table Models
リレーションの中間テーブルを表す、カスタムモデルを定義したい場合は、リレーション定義でusing
メソッドを呼び出します。カスタム多対多ピボットモデルは、Illuminate\Database\Eloquent\Relations\Pivot
クラス、一方のカスタムポリモーフィック多対多ピボットモデルは、Illuminate\Database\Eloquent\Relations\MorphPivot
クラスを拡張する必要があります。例として、カスタムRoleUser
ピボットモデルを使用する、Role
を定義してみましょう。If you would like to define a custom model to represent the intermediate table of your relationship, you may call the using
method when defining the relationship. Custom many-to-many pivot models should extend the Illuminate\Database\Eloquent\Relations\Pivot
class while custom polymorphic many-to-many pivot models should extend the Illuminate\Database\Eloquent\Relations\MorphPivot
class. For example, we may define a Role
which uses a custom RoleUser
pivot model:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Role extends Model
{
/**
* 役目を所有するユーザー
*/
public function users()
{
return $this->belongsToMany('App\User')->using('App\RoleUser');
}
}
RoleUser
定義時に、Pivot
クラスを拡張します。When defining the RoleUser
model, we will extend the Pivot
class:
<?php
namespace App;
use Illuminate\Database\Eloquent\Relations\Pivot;
class RoleUser extends Pivot
{
//
}
中間テーブルからカラムを取得するために、using
とwithPivot
を組み合わせられます。たとえば、withPivot
メソッドにカラム名を渡すことにより、RoleUser
ピボットテーブルからcreated_by
とupdated_by
カラムを取得してみましょう。You can combine using
and withPivot
in order to retrieve columns from the intermediate table. For example, you may retrieve the created_by
and updated_by
columns from the RoleUser
pivot table by passing the column names to the withPivot
method:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Role extends Model
{
/**
* 役目を所有するユーザー
*/
public function users()
{
return $this->belongsToMany('App\User')
->using('App\RoleUser')
->withPivot([
'created_by',
'updated_by',
]);
}
}
注意: ピボットモデルでは、
SoftDeletes
トレイトを使わないほうが良いでしょう。ピボットレコードのソフト削除が必要な場合は、ピボットモデルを実際のEloquentモデルに変換することを考えてください。Note: Pivot models may not use theSoftDeletes
trait. If you need to soft delete pivot records consider converting your pivot model to an actual Eloquent model.
カスタム中間テーブルとIDの増分Custom Pivot Models And Incrementing IDs
カスタム中間テーブルを使用し、多対多リレーションを定義しており、その中間テーブルが自動増加する主キーを持つ場合、カスタム中間テーブルクラスのincrementing
プロパティをtrue
にセットしてください。If you have defined a many-to-many relationship that uses a custom pivot model, and that pivot model has an auto-incrementing primary key, you should ensure your custom pivot model class defines an incrementing
property that is set to true
.
/**
* IDの自動増加
*
* @var bool
*/
public $incrementing = true;
Has One ThroughHas One Through
"has-one-through"(〜経由で1つへ紐づく)リレーションは、一つの仲介関係を通しモデルを関連付けます。The "has-one-through" relationship links models through a single intermediate relation.
たとえば、自動車修理工場のアプリケーションでは、各整備士(Mechanic
)が車(Car
)を1つ所有し、各車が所有者(Owner
)を1つ所有します。Mechanic
とOwner
は直接関係していませんが、Mechanic
はOwner
を通じて(through)Car
へアクセスできます。このリレーションを定義するために必要なテーブルを見てみましょう:For example, in a vehicle repair shop application, each Mechanic
may have one Car
, and each Car
may have one Owner
. While the Mechanic
and the Owner
have no direct connection, the Mechanic
can access the Owner
through the Car
itself. Let's look at the tables necessary to define this relationship:
mechanics
id - integer
name - string
cars
id - integer
model - string
mechanic_id - integer
owners
id - integer
name - string
car_id - integer
これでリレーションのテーブル構造が確認できました。では、Mechanic
モデル上でリレーションを定義してみましょう。Now that we have examined the table structure for the relationship, let's define the relationship on the Mechanic
model:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Mechanic extends Model
{
/**
* 車のオーナーを取得
*/
public function carOwner()
{
return $this->hasOneThrough('App\Owner', 'App\Car');
}
}
hasOneThrough
メソッドの第1引数は、アクセスしたい最終的なモデル名で、第2引数は仲介するモデルの名前です。The first argument passed to the hasOneThrough
method is the name of the final model we wish to access, while the second argument is the name of the intermediate model.
通常、Eloquent外部キー規約は、リレーションのクエリを実行するときに使用されます。リレーションのキーをカスタマイズしたい場合は、hasOneThrough
メソッドの第3引数、第4引数に渡します。第3引数は仲介モデルの外部キー名です。第4引数は最終モデルの外部キーの名前です。第5引数はローカルキー、第6引数は仲介モデルのローカルキーです。Typical Eloquent foreign key conventions will be used when performing the relationship's queries. If you would like to customize the keys of the relationship, you may pass them as the third and fourth arguments to the hasOneThrough
method. The third argument is the name of the foreign key on the intermediate model. The fourth argument is the name of the foreign key on the final model. The fifth argument is the local key, while the sixth argument is the local key of the intermediate model:
class Mechanic extends Model
{
/**
* 車のオーナーを取得
*/
public function carOwner()
{
return $this->hasOneThrough(
'App\Owner',
'App\Car',
'mechanic_id', // carsテーブルの外部キー
'car_id', // ownersテーブルの外部キー
'id', // mechanicsテーブルのローカルキー
'id' // carsテーブルのローカルキー
);
}
}
Has Many ThroughHas Many Through
has many through(〜経由で多数へ紐づく)リレーションは、仲介するテーブルを通して直接関連付けしていないテーブルへアクセスするために、便利な近道を提供します。たとえばCountry
モデルはUsers
モデルを経由して、多くのPosts
を所有することでしょう。テーブルは以下のような構成になります。The "has-many-through" relationship provides a convenient shortcut for accessing distant relations via an intermediate relation. For example, a Country
model might have many Post
models through an intermediate User
model. In this example, you could easily gather all blog posts for a given country. Let's look at the tables required to define this relationship:
countries
id - integer
name - string
users
id - integer
country_id - integer
name - string
posts
id - integer
user_id - integer
title - string
たとえposts
テーブルにcountry_id
が存在しなくても、hasManyThrough
リレーションではCountryのPostへ$country->posts
によりアクセスできます。このクエリを行うためにEloquentは仲介するusers
テーブルのcountry_id
を調べます。一致するユーザーIDが存在していたらposts
テーブルのクエリに利用します。Though posts
does not contain a country_id
column, the hasManyThrough
relation provides access to a country's posts via $country->posts
. To perform this query, Eloquent inspects the country_id
on the intermediate users
table. After finding the matching user IDs, they are used to query the posts
table.
ではリレーションのテーブル構造を理解したところで、Country
モデルを定義しましょう。Now that we have examined the table structure for the relationship, let's define it on the Country
model:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Country extends Model
{
/**
* この国の全ポストを取得
*/
public function posts()
{
return $this->hasManyThrough('App\Post', 'App\User');
}
}
hasManyThrough
メソッドの第一引数は最終的にアクセスしたいモデル名で、第2引数は仲介するモデル名です。The first argument passed to the hasManyThrough
method is the name of the final model we wish to access, while the second argument is the name of the intermediate model.
リレーションのクエリ実行時は、典型的なEloquentの外部キー規約が使用されます。リレーションのキーをカスタマイズしたい場合は、hasManyThrough
メソッドの第3引数と、第4引数を指定してください。第3引数は仲介モデルの外部キー名、第4引数は最終的なモデルの外部キー名です。第5引数はローカルキーで、第6引数は仲介モデルのローカルキーです。Typical Eloquent foreign key conventions will be used when performing the relationship's queries. If you would like to customize the keys of the relationship, you may pass them as the third and fourth arguments to the hasManyThrough
method. The third argument is the name of the foreign key on the intermediate model. The fourth argument is the name of the foreign key on the final model. The fifth argument is the local key, while the sixth argument is the local key of the intermediate model:
class Country extends Model
{
public function posts()
{
return $this->hasManyThrough(
'App\Post',
'App\User',
'country_id', // usersテーブルの外部キー
'user_id', // postsテーブルの外部キー
'id', // countriesテーブルのローカルキー
'id' // usersテーブルのローカルキー
);
}
}
ポリモーフィックリレーションPolymorphic Relationships
ポリモーフィック(Polymorphic:多様性)リレーションは一つの関係で、対象となるモデルを複数のモデルに所属させます。A polymorphic relationship allows the target model to belong to more than one type of model using a single association.
1対1(ポリモーフィック)One To One (Polymorphic)
テーブル構造Table Structure
1対1ポリモーフィックリレーションは、1対1リレーションと似ています。しかしながら一つの関連付けで、対象モデルが複数のタイプのモデルに所属できる点が異なります。たとえば、ブログのPost
とUser
が、Image
モデルに対してポリモーフィックリレーションを共有しているとしましょう。1対1ポリモーフィックリレーションを使えば、1つでブログポストとユーザーアカウント両方に対し使用できる、画像のリストを利用できます。最初に、テーブル構造を見てみましょう。A one-to-one polymorphic relation is similar to a simple one-to-one relation; however, the target model can belong to more than one type of model on a single association. For example, a blog Post
and a User
may share a polymorphic relation to an Image
model. Using a one-to-one polymorphic relation allows you to have a single list of unique images that are used for both blog posts and user accounts. First, let's examine the table structure:
posts
id - integer
name - string
users
id - integer
name - string
images
id - integer
url - string
imageable_id - integer
imageable_type - string
imageable_id
とimageable_type
カラムに注目してください。imageable_id
カラムは、ポストかユーザーのID値を含みます。一方のimageable_type
カラムは、親モデルのクラス名を含みます。imageable
関係がアクセスされた場合に、Eloquentによりimageable_type
カラムは親のモデルがどんな「タイプ」であるかを決めるために使用されます。Take note of the imageable_id
and imageable_type
columns on the images
table. The imageable_id
column will contain the ID value of the post or user, while the imageable_type
column will contain the class name of the parent model. The imageable_type
column is used by Eloquent to determine which "type" of parent model to return when accessing the imageable
relation.
モデル構造Model Structure
次に、このリレーションを構築するために必要なモデルの定義を確認しましょう。Next, let's examine the model definitions needed to build this relationship:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Image extends Model
{
/**
* 所有しているimageableモデルの取得
*/
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');
}
}
リレーションの取得Retrieving The Relationship
データベーステーブルとモデルが定義できたら、モデルを使いリレーションへアクセスできます。例として、ポストに対するイメージを取得してみましょう。image
動的プロパティが使用できます。Once your database table and models are defined, you may access the relationships via your models. For example, to retrieve the image for a post, we can use the image
dynamic property:
$post = App\Post::find(1);
$image = $post->image;
morphTo
を実行する名前のメソッドでアクセスすれば、ポリモーフィックモデルから親を取得することもできます。この場合、Image
モデル上のimageable
メソッドです。では、このメソッドを動的プロパティとして呼び出してみましょう。You may also retrieve the parent from the polymorphic model by accessing the name of the method that performs the call to morphTo
. In our case, that is the imageable
method on the Image
model. So, we will access that method as a dynamic property:
$image = App\Image::find(1);
$imageable = $image->imageable;
Image
モデル上のimageable
リレーションは、そのイメージを所有しているモデルのタイプにより、Post
かUser
インスタンスのどちらかを返します。morphTo
リレーションのカスタムtype
とid
カラムを指定する必要がある場合は、メソッド名と完全に一致するリレーション名を最初の引数に必ず渡してください。The imageable
relation on the Image
model will return either a Post
or User
instance, depending on which type of model owns the image. If you need to specify custom type
and id
columns for the morphTo
relation, always ensure you pass the relationship name (which should exactly match the method name) as the first parameter:
/**
* イメージが所属するモデルを取得する
*/
public function imageable()
{
return $this->morphTo(__FUNCTION__, 'imageable_type', 'imageable_id');
}
1対多(ポリモーフィック)One To Many (Polymorphic)
テーブル構造Table Structure
1対多ポリモーフィックリレーションは、シンプルな1対多リレーションと似ています。しかしながら一つの関連付けで、対象モデルが複数のタイプのモデルに所属できる点が異なります。たとえば、アプリケーションのユーザーが、ポストと動画の両方へ「コメント」できるようにすると想像してください。ポリモーフィックリレーションを使用すれば、両方のシナリオに対し一つのcomments
テーブルで対処できます。最初に、このリレーションを構築するために必要な、テーブル構造を確認しましょう。A one-to-many polymorphic relation is similar to a simple one-to-many relation; however, the target model can belong to more than one type of model on a single association. For example, imagine users of your application can "comment" on both posts and videos. Using polymorphic relationships, you may use a single comments
table for both of these scenarios. First, let's examine the table structure required to build this relationship:
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
モデル構造Model Structure
次に、このリレーションを構築するために必要なモデルの定義を確認しましょう。Next, let's examine the model definitions needed to build this relationship:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Comment extends Model
{
/**
* 所有しているcommentableモデルの取得
*/
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');
}
}
リレーションの取得Retrieving The Relationship
データベーステーブルとモデルが定義できたら、モデルを使いリレーションにアクセスできます。たとえば、あるポストの全コメントへアクセスするには、comments
動的プロパティを使います。Once your database table and models are defined, you may access the relationships via your models. For example, to access all of the comments for a post, we can use the comments
dynamic property:
$post = App\Post::find(1);
foreach ($post->comments as $comment) {
//
}
morphTo
の呼び出しを行うメソッドの名前にアクセスすることにより、ポリモーフィック関連の所有者を取得することもできます。この例の場合、Comment
モデルのcommentable
メソッドです。では、このメソッドに動的プロパティによりアクセスしましょう。You may also retrieve the owner of a polymorphic relation from the polymorphic model by accessing the name of the method that performs the call to morphTo
. In our case, that is the commentable
method on the Comment
model. So, we will access that method as a dynamic property:
$comment = App\Comment::find(1);
$commentable = $comment->commentable;
Comment
モデルのcommentable
関係は、Post
かvideo
インスタンスのどちらかを返します。そのコメントを所有しているモデルのタイプにより決まります。The commentable
relation on the Comment
model will return either a Post
or Video
instance, depending on which type of model owns the comment.
多対多(ポリモーフィック)Many To Many (Polymorphic)
テーブル構造Table Structure
多対多ポリモーフィックリレーションは、morphOne
やmorphMany
リレーションより、少々複雑です。例として、ブログのPost
とVideo
モデルがTag
モデルに対し、ポリモーフィックリレーションを共有しているとしましょう。多対多ポリモーフィックリレーションにより、一つのユニークなタグリストをブログポストと動画両方で共有できます。最初に、テーブル構造を確認してください。Many-to-many polymorphic relations are slightly more complicated than morphOne
and morphMany
relationships. For example, a blog Post
and Video
model could share a polymorphic relation to a Tag
model. Using a many-to-many polymorphic relation allows you to have a single list of unique tags that are shared across blog posts and videos. First, let's examine the table structure:
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
モデル構造Model Structure
次にモデルにその関係を用意しましょう。Post
とVideo
モデルは両方ともベースのEloquentクラスのmorphToMany
メソッドを呼び出すtags
メソッドを持っています。Next, we're ready to define the relationships on the model. The Post
and Video
models will both have a tags
method that calls the morphToMany
method on the base Eloquent class:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Post extends Model
{
/**
* ポストに対する全タグを取得
*/
public function tags()
{
return $this->morphToMany('App\Tag', 'taggable');
}
}
逆の関係の定義Defining The Inverse Of The Relationship
次にTag
モデルで関係する各モデルに対するメソッドを定義する必要があります。たとえばこの例であれば、posts
メソッドとvideos
メソッドを用意します。Next, on the Tag
model, you should define a method for each of its related models. So, for this example, we will define a posts
method and a videos
method:
<?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');
}
}
リレーションの取得Retrieving The Relationship
データベーステーブルとモデルが定義できたら、モデルを使いリレーションにアクセスできます。たとえば、ポストに対する全タグへアクセスするには、単にtags
動的プロパティを使用します。Once your database table and models are defined, you may access the relationships via your models. For example, to access all of the tags for a post, you can use the tags
dynamic property:
$post = App\Post::find(1);
foreach ($post->tags as $tag) {
//
}
さらにmorphedByMany
を呼び出すメソッドの名前にアクセスし、ポリモーフィックモデルからポリモーフィックリレーションの所有者を取得することも可能です。この例の場合Tag
モデルのposts
とvideos
メソッドです。では動的プロパティとしてメソッドを呼び出しましょう。You may also retrieve the owner of a polymorphic relation from the polymorphic model by accessing the name of the method that performs the call to morphedByMany
. In our case, that is the posts
or videos
methods on the Tag
model. So, you will access those methods as dynamic properties:
$tag = App\Tag::find(1);
foreach ($tag->videos as $video) {
//
}
カスタムポリモーフィックタイプCustom Polymorphic Types
関連付けたモデルのタイプを保存するため、デフォルトでLaravelははっきりと識別できるクラス名を使います。たとえば上記の例で、Comment
がPost
かVideo
に所属しているとすると、commentable_type
はデフォルトでApp\Post
かApp\Video
のどちらかになるでしょう。しかし、データーベースをアプリケーションの内部構造と分離したい場合もあります。その場合、リレーションの"morph map"を定義し、クラス名の代わりに使用する、各モデルに関連づいたテーブル名をEloquentへ指示できます。By default, Laravel will use the fully qualified class name to store the type of the related model. For instance, given the one-to-many example above where a Comment
may belong to a Post
or a Video
, the default commentable_type
would be either App\Post
or App\Video
, respectively. However, you may wish to decouple your database from your application's internal structure. In that case, you may define a "morph map" to instruct Eloquent to use a custom name for each model instead of the class name:
use Illuminate\Database\Eloquent\Relations\Relation;
Relation::morphMap([
'posts' => 'App\Post',
'videos' => 'App\Video',
]);
morphMap
は、AppServiceProvider
のboot
関数で登録できますし、お望みであれば独立したサービスプロバイダを作成し、その中で行うこともできます。You may register the morphMap
in the boot
function of your AppServiceProvider
or create a separate service provider if you wish.
Note:
既存のアプリケーションへ"morph map"を追加する場合は、データベース中のすべてのmorphable*_type
カラムの値は完全なクラス名を持っており、"map"名へ変換する必要が起きます。{note} When adding a "morph map" to your existing application, every morphable*_type
column value in your database that still contains a fully-qualified class will need to be converted to its "map" name.
getMorphClass
メソッドを使用し、実行時の指定モデルのmorph別名を求められます。逆に、Relation::getMorphedModel
メソッドを使い、morph別名に関連付けたクラスの完全な名前を求めることもできます。You may determine the morph alias of a given model at runtime using the getMorphClass
method. Conversely, you may determine the fully-qualified class name associated with a morph alias using the Relation::getMorphedModel
method:
use Illuminate\Database\Eloquent\Relations\Relation;
$alias = $post->getMorphClass();
$class = Relation::getMorphedModel($alias);
動的リレーションDynamic Relationships
resolveRelationUsing
メソッドにより、実行時にEloquentモデル間のリレーションを定義できます。通常のアプリケーション開発では通常推奨できませんが、Laravelパッケージの開発時には時に便利でしょう。You may use the resolveRelationUsing
method to define relations between Eloquent models at runtime. While not typically recommended for normal application development, this may occasionally be useful when developing Laravel packages:
use App\Order;
use App\Customer;
Order::resolveRelationUsing('customer', function ($orderModel) {
return $orderModel->belongsTo(Customer::class, 'customer_id');
});
Note: {note} When defining dynamic relationships, always provide explicit key name arguments to the Eloquent relationship methods.
動的リレーションを定義するときは常にEloquentリレーションメソッドの引数に明確なキー名を渡してください。
リレーションのクエリQuerying Relations
Eloquentリレーションはすべてメソッドとして定義されているため、リレーションのクエリを実際に記述しなくても、メソッドを呼び出すことで、そのリレーションのインスタンスを取得できます。さらに、すべてのタイプのEloquentリレーションもクエリビルダとしても動作し、データベースに対してSQLが最終的に実行される前に、そのリレーションのクエリをチェーンで続けて記述できます。Since all types of Eloquent relationships are defined via methods, you may call those methods to obtain an instance of the relationship without actually executing the relationship queries. In addition, all types of Eloquent relationships also serve as query builders[/docs/{{version}}/queries], allowing you to continue to chain constraints onto the relationship query before finally executing the SQL against your database.
たとえばブログシステムで関連した多くのPost
モデルを持つUser
モデルを想像してください。For example, imagine a blog system in which a User
model has many associated Post
models:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{
/**
* ユーザーの全ポストの取得
*/
public function posts()
{
return $this->hasMany('App\Post');
}
}
次のようにposts
リレーションのクエリに追加の制約を付け加えられます。You may query the posts
relationship and add additional constraints to the relationship like so:
$user = App\User::find(1);
$user->posts()->where('active', 1)->get();
すべてのクエリビルダメソッドをリレーションで使用することも可能です。ですから、提供している全メソッドを学ぶために、クエリビルダのドキュメントを研究してください。You are able to use any of the query builder[/docs/{{version}}/queries] methods on the relationship, so be sure to explore the query builder documentation to learn about all of the methods that are available to you.
リレーションにorWhere
を続けるChaining orWhere
Clauses After Relationships
前記の例では、リレーションのクエリ時に制約を自由に追加できることをデモンストレーションしました。しかし、orWhere
節はリレーション制約として、同じレベルの論理グループにしてしまうため、使用には注意が必要です。As demonstrated in the example above, you are free to add additional constraints to relationships when querying them. However, use caution when chaining orWhere
clauses onto a relationship, as the orWhere
clauses will be logically grouped at the same level as the relationship constraint:
$user->posts()
->where('active', 1)
->orWhere('votes', '>=', 100)
->get();
// select * from posts
// where user_id = ? and active = 1 or votes >= 100
多くの状況では、カッコで挟まれた条件チェックの論理グループにするため、制約グループを使うほうが目的に叶うでしょう。In most situations, you likely intend to use constraint groups[/docs/{{version}}/queries#parameter-grouping] to logically group the conditional checks between parentheses:
use Illuminate\Database\Eloquent\Builder;
$user->posts()
->where(function (Builder $query) {
return $query->where('active', 1)
->orWhere('votes', '>=', 100);
})
->get();
// select * from posts
// where user_id = ? and (active = 1 or votes >= 100)
リレーションメソッド対動的プロパティRelationship Methods Vs. Dynamic Properties
リレーションクエリに追加の制約を加える必要がなければ、そのリレーションへプロパティとしてアクセスできます。User
とPost
の例を続けるとして、ユーザーの全ポストには次のようにアクセスできます。If you do not need to add additional constraints to an Eloquent relationship query, you may access the relationship as if it were a property. For example, continuing to use our User
and Post
example models, we may access all of a user's posts like so:
$user = App\User::find(1);
foreach ($user->posts as $post) {
//
}
動的プロパティは「遅延ロード」されます。つまり実際にアクセスされた時にだけそのリレーションのデータはロードされます。そのため開発者は多くの場合にEagerローディングを使い、モデルをロードした後にアクセスするリレーションを前もってロードしておきます。Eagerロードはモデルのリレーションをロードするため実行されるSQLクエリを大幅に減らしてくれます。Dynamic properties are "lazy loading", meaning they will only load their relationship data when you actually access them. Because of this, developers often use eager loading[#eager-loading] to pre-load relationships they know will be accessed after loading the model. Eager loading provides a significant reduction in SQL queries that must be executed to load a model's relations.
存在するリレーションのクエリQuerying Relationship Existence
関連付けたモデルのレコードに基づいて、モデルのレコードに対するマッチングを絞り込みたい場合もあるでしょう。たとえば、最低でも一つのコメントを持つ、全ブログポストを取得したい場合を考えてください。これを行うためには、リレーションの名前をhas
とorHas
メソッドに渡します。When accessing the records for a model, you may wish to limit your results based on the existence of a relationship. For example, imagine you want to retrieve all blog posts that have at least one comment. To do so, you may pass the name of the relationship to the has
and orHas
methods:
// 最低1つのコメントを持つ全ポストの取得
$posts = App\Post::has('comments')->get();
演算子と数を指定しクエリをカスタマイズすることもできます。You may also specify an operator and count to further customize the query:
// 3つ以上のコメントを持つ全ポストの取得
$posts = App\Post::has('comments', '>=', 3)->get();
ネストしたhas
文は「ドット」記法で組立てられます。たとえば最低一つのコメントと評価を持つ全ポストを取得する場合です。Nested has
statements may also be constructed using "dot" notation. For example, you may retrieve all posts that have at least one comment and vote:
// 最低1つのコメントと、それに対する評価を持つポストの取得
$posts = App\Post::has('comments.votes')->get();
もっと強力な機能がお望みならばhas
の問い合わせに"WHERE"で条件を付けられる、whereHas
やorWhereHas
を利用してください。これらのメソッドによりリレーションの制約にカスタマイズした制約を追加できます。たとえばコメントの内容を調べることです。If you need even more power, you may use the whereHas
and orWhereHas
methods to put "where" conditions on your has
queries. These methods allow you to add customized constraints to a relationship constraint, such as checking the content of a comment:
use Illuminate\Database\Eloquent\Builder;
// foo%に似たようなワードを含むコメントを最低一つ持つポストの取得
$posts = App\Post::whereHas('comments', function (Builder $query) {
$query->where('content', 'like', 'foo%');
})->get();
// foo%に似たようなワードを含むコメントを最低10個持つポストの取得
$posts = App\Post::whereHas('comments', function (Builder $query) {
$query->where('content', 'like', 'foo%');
}, '>=', 10)->get();
存在しないリレーションのクエリQuerying Relationship Absence
モデルへアクセスする時に、結果をリレーションを持たないレコードに限定したい場合があります。たとえばブログで、コメントを持たないポストのみすべて取得したい場合です。これを行うには、doesntHave
とorDoesntHave
メソッドにリレーション名を渡してください。When accessing the records for a model, you may wish to limit your results based on the absence of a relationship. For example, imagine you want to retrieve all blog posts that don't have any comments. To do so, you may pass the name of the relationship to the doesntHave
and orDoesntHave
methods:
$posts = App\Post::doesntHave('comments')->get();
もっと強力な機能がお望みなら、doesntHave
クエリに"WHERE"で条件を付けられる、whereDoesntHave
とorWhereDoesntHave
メソッドを使ってください。これらのメソッドはコメントの内容を調べるなど、リレーション制約にカスタム制約を付け加えられます。If you need even more power, you may use the whereDoesntHave
and orWhereDoesntHave
methods to put "where" conditions on your doesntHave
queries. These methods allows you to add customized constraints to a relationship constraint, such as checking the content of a comment:
use Illuminate\Database\Eloquent\Builder;
$posts = App\Post::whereDoesntHave('comments', function (Builder $query) {
$query->where('content', 'like', 'foo%');
})->get();
「ドット」記法を使い、ネストしたリレーションに対してクエリを実行できます。たとえば、以下のクエリによりコメントを持っておらず、アカウントを無効(ban)にされていない著者によるコメントが存在するすべてのポストを取得できます。You may use "dot" notation to execute a query against a nested relationship. For example, the following query will retrieve all posts that do not have comments and posts that have comments from authors that are not banned:
use Illuminate\Database\Eloquent\Builder;
$posts = App\Post::whereDoesntHave('comments.author', function (Builder $query) {
$query->where('banned', 0);
})->get();
ポリモーフィックリレーションのクエリQuerying Polymorphic Relationships
既存のMorphTo
リレーションへクエリするには、whereHasMorph
とこれに対応するメソッドを利用してください。To query the existence of MorphTo
relationships, you may use the whereHasMorph
method and its corresponding methods:
use Illuminate\Database\Eloquent\Builder;
// ポストとビデオと関連付いているコメントをtitle like foo%で取得する
$comments = App\Comment::whereHasMorph(
'commentable',
['App\Post', 'App\Video'],
function (Builder $query) {
$query->where('title', 'like', 'foo%');
}
)->get();
// ポストとビデオと関連付いているコメントをtitle not like foo%で取得する
$comments = App\Comment::whereDoesntHaveMorph(
'commentable',
'App\Post',
function (Builder $query) {
$query->where('title', 'like', 'foo%');
}
)->get();
関連するモデルに応じて異なった制約を追加するために、$type
パラメータを使用できます。You may use the $type
parameter to add different constraints depending on the related model:
use Illuminate\Database\Eloquent\Builder;
$comments = App\Comment::whereHasMorph(
'commentable',
['App\Post', 'App\Video'],
function (Builder $query, $type) {
$query->where('title', 'like', 'foo%');
if ($type === 'App\Post') {
$query->orWhere('content', 'like', 'foo%');
}
}
)->get();
ポリモーフィックモデルの配列を渡す代わりに*
をワイルドカードとして指定でき、その場合はデータベースからすべてのポリモーフィックタイプをLaravelは取得します。Instead of passing an array of possible polymorphic models, you may provide *
as a wildcard and let Laravel retrieve all the possible polymorphic types from the database. Laravel will execute an additional query in order to perform this operation:
use Illuminate\Database\Eloquent\Builder;
$comments = App\Comment::whereHasMorph('commentable', '*', function (Builder $query) {
$query->where('title', 'like', 'foo%');
})->get();
関連するモデルのカウントCounting Related Models
リレーション結果の件数を実際にレコードを読み込むことなく知りたい場合は、withCount
メソッドを使います。件数は結果のモデルの{リレーション名}_count
カラムに格納されます。If you want to count the number of results from a relationship without actually loading them you may use the withCount
method, which will place a {relation}_count
column on your resulting models. For example:
$posts = App\Post::withCount('comments')->get();
foreach ($posts as $post) {
echo $post->comments_count;
}
クエリによる制約を加え、複数のリレーションの件数を取得することも可能です。You may add the "counts" for multiple relations as well as add constraints to the queries:
use Illuminate\Database\Eloquent\Builder;
$posts = App\Post::withCount(['votes', 'comments' => function (Builder $query) {
$query->where('content', 'like', 'foo%');
}])->get();
echo $posts[0]->votes_count;
echo $posts[0]->comments_count;
同じリレーションに複数の件数を含めるため、リレーション件数結果の別名も付けられます。You may also alias the relationship count result, allowing multiple counts on the same relationship:
use Illuminate\Database\Eloquent\Builder;
$posts = App\Post::withCount([
'comments',
'comments as pending_comments_count' => function (Builder $query) {
$query->where('approved', false);
},
])->get();
echo $posts[0]->comments_count;
echo $posts[0]->pending_comments_count;
select
文にwithCount
を組み合わせる場合は、select
文の後でwithCount
を呼び出してください。If you're combining withCount
with a select
statement, ensure that you call withCount
after the select
method:
$posts = App\Post::select(['title', 'body'])->withCount('comments')->get();
echo $posts[0]->title;
echo $posts[0]->body;
echo $posts[0]->comments_count;
さらに、loadCount
メソッドを使い、親モデルを取得した後からリレーションの件数をロードすることもできます。In addition, using the loadCount
method, you may load a relationship count after the parent model has already been retrieved:
$book = App\Book::first();
$book->loadCount('genres');
Eagerロードのクエリに追加の制約を指定する必要がある場合は、ロードしたいリレーションをキーとする配列を渡すことができます。If you need to set additional query constraints on the eager loading query, you may pass an array keyed by the relationships you wish to load. The array values should be Closure
instances which receive the query builder instance:
$book->loadCount(['reviews' => function ($query) {
$query->where('rating', 5);
}])
ポリモーフィックリレーションで関連モデルを数えるCounting Related Models On Polymorphic Relationships
morphTo
リレーションでEagerロードし、同時にそのネストしたリレーションが返す可能性のあるさまざまなエンティティを数え上げたい場合は、with
メソッドをmorphTo
リレーションのmorphWithCount
メソッドと組み合わせ使用します。If you would like to eager load a morphTo
relationship, as well as nested relationship counts on the various entities that may be returned by that relationship, you may use the with
method in combination with the morphTo
relationship's morphWithCount
method.
以下の例は、Photo
とPost
モデルがActivityFeed
モデルを生成していると想定してください。さらに、Photo
モデルはTag
モデルと関係し、Post
モデルはComment
モデルと関係していると想定してください。In this example, let's assume Photo
and Post
models may create ActivityFeed
models. Additionally, let's assume that Photo
models are associated with Tag
models, and Post
models are associated with Comment
models.
こうしたモデルの定義とリレーションを使い、ActivityFeed
モデルインスタンスを取得し、すべてのparentable
モデルと、それぞれのネストしたリレーション件数をEagerロードできます。Using these model definitions and relationships, we may retrieve ActivityFeed
model instances and eager load all parentable
models and their respective nested relationship counts:
use Illuminate\Database\Eloquent\Relations\MorphTo;
$activities = ActivityFeed::query()
->with(['parentable' => function (MorphTo $morphTo) {
$morphTo->morphWithCount([
Photo::class => ['tags'],
Post::class => ['comments'],
]);
}])->get();
さらに、ActivityFeed
モデルがすでに取得済みであればポリモーフィズムリレーションのさまざまなエンティティ上ですべてのネストしたリレーション件数をEagerロードするため、loadMorphCount
メソッドを使用できます。In addition, you may use the loadMorphCount
method to eager load all nested relationship counts on the various entities of the polymorphic relation if the ActivityFeed
models have already been retrieved:
$activities = ActivityFeed::with('parentable')
->get()
->loadMorphCount('parentable', [
Photo::class => ['tags'],
Post::class => ['comments'],
]);
EagerロードEager Loading
プロパティとしてEloquentリレーションにアクセスする場合、そのリレーションデータは「遅延ロード」されます。つまり、そのプロパティへ最初にアクセスするまで、実際にはロードされません。しかし、Eloquentでは、親のモデルに対するクエリと同時にリレーションを「Eagerロード」可能です。EagerロードはN+1クエリ問題の解決策です。N+1クエリ問題を理解するために、Author
と関連しているBook
モデルを考えてみてください。When accessing Eloquent relationships as properties, the relationship data is "lazy loaded". This means the relationship data is not actually loaded until you first access the property. However, Eloquent can "eager load" relationships at the time you query the parent model. Eager loading alleviates the N + 1 query problem. To illustrate the N + 1 query problem, consider a Book
model that is related to Author
:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Book extends Model
{
/**
* この本を書いた著者を取得
*/
public function author()
{
return $this->belongsTo('App\Author');
}
}
では全書籍とその著者を取得しましょう。Now, let's retrieve all books and their authors:
$books = App\Book::all();
foreach ($books as $book) {
echo $book->author->name;
}
このループではまずすべての本をテーブルから取得するために1クエリ実行され、それから著者をそれぞれの本について取得します。ですから25冊あるならば、このループで26クエリが発生します。This loop will execute 1 query to retrieve all of the books on the table, then another query for each book to retrieve the author. So, if we have 25 books, this loop would run 26 queries: 1 for the original book, and 25 additional queries to retrieve the author of each book.
うれしいことにクエリの数を徹底的に減らすために、Eagerローディングを使うことができます。with
メソッドを使い指定してください。Thankfully, we can use eager loading to reduce this operation to just 2 queries. When querying, you may specify which relationships should be eager loaded using the with
method:
$books = App\Book::with('author')->get();
foreach ($books as $book) {
echo $book->author->name;
}
この操作では2つだけしかクエリが実行されません。For this operation, only two queries will be executed:
select * from books
select * from authors where id in (1, 2, 3, 4, 5, ...)
複数のリレーションに対するEagerロードEager Loading Multiple Relationships
一回の操作で異なった複数のリレーションをEagerロードする必要がある場合もあります。その場合でも、with
メソッドに引数を追加で渡すだけです。Sometimes you may need to eager load several different relationships in a single operation. To do so, just pass additional arguments to the with
method:
$books = App\Book::with(['author', 'publisher'])->get();
ネストしたEagerロードNested Eager Loading
ネストしたリレーションをEagerロードする場合は「ドット」記法が使用できます。例としてEloquent文で全著者と著者個人のコンタクトも全部Eagerロードしてみましょう。To eager load nested relationships, you may use "dot" syntax. For example, let's eager load all of the book's authors and all of the author's personal contacts in one Eloquent statement:
$books = App\Book::with('author.contacts')->get();
morphTo
リレーションのネストしたEagerロードNested Eager Loading morphTo
Relationships
リレーションにより返されるさまざまなエンティティのリレーションがネストしている、morphTo
リレーションをEagerロードしたい場合は、with
メソッドをmorphTo
リレーションのmorphWith
メソッドと組み合わせて使用します。If you would like to eager load a morphTo
relationship, as well as nested relationships on the various entities that may be returned by that relationship, you may use the with
method in combination with the morphTo
relationship's morphWith
method. To help illustrate this method, let's consider the following model:
<?php
use Illuminate\Database\Eloquent\Model;
class ActivityFeed extends Model
{
/**
* アクティビティフィードレコードの親を取得
*/
public function parentable()
{
return $this->morphTo();
}
}
この例の場合、Event
、Photo
、Post
モデルでActivityFeed
モデルを構成していると仮定しましょう。さらに、Event
モデルはCalendar
モデルへ所属し、Photo
モデルはTag
モデルと関連し、Post
モデルはAuthor
モデルへ所属しているとしましょう。In this example, let's assume Event
, Photo
, and Post
models may create ActivityFeed
models. Additionally, let's assume that Event
models belong to a Calendar
model, Photo
models are associated with Tag
models, and Post
models belong to an Author
model.
このモデル定義とリレーションを使用して、ActivityFeed
モデルインスタンスを取得し、全parentable
モデルとそれぞれのネストしたリレーションをEagerロードできます。Using these model definitions and relationships, we may retrieve ActivityFeed
model instances and eager load all parentable
models and their respective nested relationships:
use Illuminate\Database\Eloquent\Relations\MorphTo;
$activities = ActivityFeed::query()
->with(['parentable' => function (MorphTo $morphTo) {
$morphTo->morphWith([
Event::class => ['calendar'],
Photo::class => ['tags'],
Post::class => ['author'],
]);
}])->get();
特定カラムのEagerロードEager Loading Specific Columns
検索しているリレーションの中ですべてのカラムが必要とは限りません。そのため、Eloquentではリレーションの中で取得したいカラムを指定できます。You may not always need every column from the relationships you are retrieving. For this reason, Eloquent allows you to specify which columns of the relationship you would like to retrieve:
$books = App\Book::with('author:id,name')->get();
Note:
この機能を使用する場合はid
カラムと、取得するカラムリスト中の関連付けられた外部キーカラムすべてを常に含める必要があります。{note} When using this feature, you should always include theid
column and any relevant foreign key columns in the list of columns you wish to retrieve.
デフォルトのEagerロードEager Loading By Default
あるモデル取得時、常にリレーションを取得したい場合もあります。そのためには、モデルに$with
プロパティを定義します。Sometimes you might want to always load some relationships when retrieving a model. To accomplish this, you may define a $with
property on the model:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Book extends Model
{
/**
* 常にロードするリレーション
*
* @var array
*/
protected $with = ['author'];
/**
* この本を書いた著者を取得
*/
public function author()
{
return $this->belongsTo('App\Author');
}
}
$with
プロパティで指定したリレーションを一つのクエリで削除したい場合は、without
メソッドを使用します。If you would like to remove an item from the $with
property for a single query, you may use the without
method:
$books = App\Book::without('author')->get();
Eagerロードへの制約Constraining Eager Loads
ときにリレーションをEagerロードしたいが、Eagerロードクエリに条件を追加したい場合があります。例を見てください。Sometimes you may wish to eager load a relationship, but also specify additional query conditions for the eager loading query. Here's an example:
$users = App\User::with(['posts' => function ($query) {
$query->where('title', 'like', '%first%');
}])->get();
この例でEloquentは、title
カラムの内容にfirst
という言葉を含むポストのみをEagerロードしています。Eagerロード操作をさらにカスタマイズするために、他のクエリビルダを呼び出すこともできます。In this example, Eloquent will only eager load posts where the post's title
column contains the word first
. You may call other query builder[/docs/{{version}}/queries] methods to further customize the eager loading operation:
$users = App\User::with(['posts' => function ($query) {
$query->orderBy('created_at', 'desc');
}])->get();
Note:
limit
とtake
クエリビルダメソッドは、Eagerロードの制約時には使用できません。{note} Thelimit
andtake
query builder methods may not be used when constraining eager loads.
遅延EagerロードLazy Eager Loading
すでに親のモデルを取得した後に、リレーションをEagerロードする必要がある場合もあるでしょう。たとえば、どの関連しているモデルをロードするかを動的に決める場合に便利です。Sometimes you may need to eager load a relationship after the parent model has already been retrieved. For example, this may be useful if you need to dynamically decide whether to load related models:
$books = App\Book::all();
if ($someCondition) {
$books->load('author', 'publisher');
}
Eagerロードに追加の制約をかける必要があるなら、ロードしたい関連へ配列のキーを付け渡してください。配列地は、クエリインスタンスを受け取る「クロージャ」でなければなりません。If you need to set additional query constraints on the eager loading query, you may pass an array keyed by the relationships you wish to load. The array values should be Closure
instances which receive the query instance:
$author->load(['books' => function ($query) {
$query->orderBy('published_date', 'asc');
}]);
リレーションをまだロードしていない場合のみロードする場合は、loadMissing
メソッドを使用します。To load a relationship only when it has not already been loaded, use the loadMissing
method:
public function format(Book $book)
{
$book->loadMissing('author');
return [
'name' => $book->name,
'author' => $book->author->name,
];
}
ネストした遅延EagerローディングとmorphTo
Nested Lazy Eager Loading & morphTo
morphTo
リレーションをEagerロードし、同時にこのリレーションが数多くのエンティティとネストしたリレーションを返す場合、loadMorph
メソッドを使用してください。If you would like to eager load a morphTo
relationship, as well as nested relationships on the various entities that may be returned by that relationship, you may use the loadMorph
method.
このメソッドは第1引数として、morphTo
リレーション名を受け取り、第2引数にはモデル/リレーションのペアの配列を引き受けます。このメソッドを理解するため、次のモデルを考えてください。This method accepts the name of the morphTo
relationship as its first argument, and an array of model / relationship pairs as its second argument. To help illustrate this method, let's consider the following model:
<?php
use Illuminate\Database\Eloquent\Model;
class ActivityFeed extends Model
{
/**
* アクティビティフィードレコードの親を取得
*/
public function parentable()
{
return $this->morphTo();
}
}
この例の場合、Event
、Photo
、Post
モデルでActivityFeed
モデルを構成していると仮定しましょう。さらに、Event
モデルはCalendar
モデルへ所属し、Photo
モデルはTag
モデルと関連し、Post
モデルはAuthor
モデルへ所属しているとしましょう。In this example, let's assume Event
, Photo
, and Post
models may create ActivityFeed
models. Additionally, let's assume that Event
models belong to a Calendar
model, Photo
models are associated with Tag
models, and Post
models belong to an Author
model.
このモデル定義とリレーションを使用して、ActivityFeed
モデルインスタンスを取得し、全parentable
モデルとそれぞれのネストしたリレーションをEagerロードできます。Using these model definitions and relationships, we may retrieve ActivityFeed
model instances and eager load all parentable
models and their respective nested relationships:
$activities = ActivityFeed::with('parentable')
->get()
->loadMorph('parentable', [
Event::class => ['calendar'],
Photo::class => ['tags'],
Post::class => ['author'],
]);
関連したモデルの挿入/更新Inserting & Updating Related Models
Save
メソッドThe Save Method
Eloquentは新しいモデルをリレーションへ追加するために便利なメソッドを用意しています。たとえばPost
モデルに新しいComment
を挿入する必要がある場合です。Comment
のpost_id
属性を自分で設定する代わりに、リレーションのsave
メソッドで直接Comment
を挿入できます。Eloquent provides convenient methods for adding new models to relationships. For example, perhaps you need to insert a new Comment
for a Post
model. Instead of manually setting the post_id
attribute on the Comment
, you may insert the Comment
directly from the relationship's save
method:
$comment = new App\Comment(['message' => 'A new comment.']);
$post = App\Post::find(1);
$post->comments()->save($comment);
動的プロパティとしてcomments
リレーションにアクセスできない点には注意してください。代わりにリレーションの取得でcomments
メソッドを呼び出しています。save
メソッドは自動的に新しいComment
モデルのpost_id
へ適した値を代入します。Notice that we did not access the comments
relationship as a dynamic property. Instead, we called the comments
method to obtain an instance of the relationship. The save
method will automatically add the appropriate post_id
value to the new Comment
model.
複数の関連したモデルを保存する必要があるなら、saveMany
メソッドを使用できます。If you need to save multiple related models, you may use the saveMany
method:
$post = App\Post::find(1);
$post->comments()->saveMany([
new App\Comment(['message' => 'A new comment.']),
new App\Comment(['message' => 'Another comment.']),
]);
save
とsaveMany
メソッドは、メモリ中に存在する親モデルのロード済みリレーションには新しいモデルを追加しません。save
とsaveMany
メソッドを使った後にリレーションへアクセスする予定がある場合は、refresh
メソッドを使い、モデルとそのリレーションを再ロードしたほうが良いでしょう。The save
and saveMany
methods will not add the new models to any in-memory relationships that are already loaded onto the parent model. If you plan on accessing the relationship after using the save
or saveMany
methods, you may wish to use the refresh
method to reload the model and its relationships:
$post->comments()->save($comment);
$post->refresh();
// 新規に保存したコメントを含む、全コメント
$post->comments;
モデルとリレーションの再帰的保存Recursively Saving Models & Relationships
モデルと関連付いているリレーションすべてを保存(save
)したい場合は、push
メソッドを使用してください。If you would like to save
your model and all of its associated relationships, you may use the push
method:
$post = App\Post::find(1);
$post->comments[0]->message = 'Message';
$post->comments[0]->author->name = 'Author Name';
$post->push();
Create
メソッドThe Create Method
save
とsaveMany
メソッドに加え、create
メソッドも使用できます。属性の配列を引数に受け付け、モデルを作成しデータベースへ挿入します。save
とcreate
の違いはsave
が完全なEloquentモデルを受け付けるのに対し、create
は普通のPHPの「配列」を受け付ける点です。In addition to the save
and saveMany
methods, you may also use the create
method, which accepts an array of attributes, creates a model, and inserts it into the database. Again, the difference between save
and create
is that save
accepts a full Eloquent model instance while create
accepts a plain PHP array
:
$post = App\Post::find(1);
$comment = $post->comments()->create([
'message' => 'A new comment.',
]);
">Tip!!
create
メソッドを使用する前に属性の複数代入に関するドキュメントを読んでおいてください。{tip} Before using thecreate
method, be sure to review the documentation on attribute mass assignment[/docs/{{version}}/eloquent#mass-assignment].
createMany
メソッドで複数のリレーションモデルを生成できます。You may use the createMany
method to create multiple related models:
$post = App\Post::find(1);
$post->comments()->createMany([
[
'message' => 'A new comment.',
],
[
'message' => 'Another new comment.',
],
]);
リレーション上のモデルを作成、変更するために、findOrNew
、firstOrNew
、firstOrCreate
、updateOrCreate
メソッドも使用できます。You may also use the findOrNew
, firstOrNew
, firstOrCreate
and updateOrCreate
methods to create and update models on relationships[https://laravel.com/docs/{{version}}/eloquent#other-creation-methods].
Belongs To関係Belongs To Relationships
belongsTo
リレーションを更新する場合はassociate
メソッドを使います。このメソッドは子モデルへ外部キーをセットします。When updating a belongsTo
relationship, you may use the associate
method. This method will set the foreign key on the child model:
$account = App\Account::find(10);
$user->account()->associate($account);
$user->save();
belongsTo
リレーションを削除する場合はdissociate
メソッドを使用します。このメソッドはリレーションの子モデルの外部キーをnull
にします。When removing a belongsTo
relationship, you may use the dissociate
method. This method will set the relationship's foreign key to null
:
$user->account()->dissociate();
$user->save();
デフォルトモデルDefault Models
belongsTo
、hasOne
、hasOneThrough
、morphOne
リレーションでは、指定したリレーションがnull
の場合に返却するデフォルトモデルを定義できます。このパターンは、頻繁にNullオブジェクトパターンと呼ばれ、コードから条件のチェックを省くのに役立ちます。以下の例では、ポストに従属するuser
がない場合に、空のApp\User
モデルを返しています。The belongsTo
, hasOne
, hasOneThrough
, and morphOne
relationships allow you to define a default model that will be returned if the given relationship is null
. This pattern is often referred to as the Null Object pattern[https://en.wikipedia.org/wiki/Null_Object_pattern] and can help remove conditional checks in your code. In the following example, the user
relation will return an empty App\User
model if no user
is attached to the post:
/**
* ポストの著者を取得
*/
public function user()
{
return $this->belongsTo('App\User')->withDefault();
}
属性を指定したデフォルトモデルを返すためには、withDefault
メソッドに配列かクロージャを渡してください。To populate the default model with attributes, you may pass an array or Closure to the withDefault
method:
/**
* ポストの著者を取得
*/
public function user()
{
return $this->belongsTo('App\User')->withDefault([
'name' => 'Guest Author',
]);
}
/**
* ポストの著者を取得
*/
public function user()
{
return $this->belongsTo('App\User')->withDefault(function ($user, $post) {
$user->name = 'Guest Author';
});
}
多対多関係Many To Many Relationships
attach/detachAttaching / Detaching
多対多リレーションを操作時により便利なように、Eloquentはヘルパメソッドをいくつか用意しています。例としてユーザーが多くの役割を持ち、役割も多くのユーザーを持てる場合を考えてみましょう。モデルを結びつけている中間テーブルにレコードを挿入することにより、ユーザーに役割を持たせるにはattach
メソッドを使います。Eloquent also provides a few additional helper methods to make working with related models more convenient. For example, let's imagine a user can have many roles and a role can have many users. To attach a role to a user by inserting a record in the intermediate table that joins the models, use the attach
method:
$user = App\User::find(1);
$user->roles()->attach($roleId);
モデルにリレーションを割りつけるときは、中間テーブルに挿入したい追加のデータを配列で渡すこともできます。When attaching a relationship to a model, you may also pass an array of additional data to be inserted into the intermediate table:
$user->roles()->attach($roleId, ['expires' => $expires]);
ユーザーから役割を削除する必要がある場合もあるでしょう。多対多リレーションのレコードを削除するにはdetach
メソッドを使います。detach
メソッドは中間テーブルから対応するレコードを削除します。しかし両方のモデルはデータベースに残ります。Sometimes it may be necessary to remove a role from a user. To remove a many-to-many relationship record, use the detach
method. The detach
method will delete the appropriate record out of the intermediate table; however, both models will remain in the database:
// ユーザーから役割を一つ切り離す
$user->roles()->detach($roleId);
// ユーザーから役割を全部切り離す
$user->roles()->detach();
便利なようにattach
とdetach
の両方共にIDの配列を指定できます。For convenience, attach
and detach
also accept arrays of IDs as input:
$user = App\User::find(1);
$user->roles()->detach([1, 2, 3]);
$user->roles()->attach([
1 => ['expires' => $expires],
2 => ['expires' => $expires],
]);
関連付けの同期Syncing Associations
多対多の関連を構築するためにsync
メソッドも使用できます。sync
メソッドへは中間テーブルに設置しておくIDの配列を渡します。その配列に指定されなかったIDは中間テーブルから削除されます。ですからこの操作が完了すると、中間テーブルには配列中のIDだけが存在することになります。You may also use the sync
method to construct many-to-many associations. The sync
method accepts an array of IDs to place on the intermediate table. Any IDs that are not in the given array will be removed from the intermediate table. So, after this operation is complete, only the IDs in the given array will exist in the intermediate table:
$user->roles()->sync([1, 2, 3]);
IDと一緒に中間テーブルの追加の値を渡すことができます。You may also pass additional intermediate table values with the IDs:
$user->roles()->sync([1 => ['expires' => true], 2, 3]);
存在しているIDを削除したくない場合は、syncWithoutDetaching
メソッドを使用します。If you do not want to detach existing IDs, you may use the syncWithoutDetaching
method:
$user->roles()->syncWithoutDetaching([1, 2, 3]);
関連の切り替えToggling Associations
多対多リレーションは、指定したIDの関連状態を「切り替える」、toggle
メソッドも提供しています。指定したIDが現在関連している場合は、関連を切り離します。同様に現在関連がない場合は、関連付けます。The many-to-many relationship also provides a toggle
method which "toggles" the attachment status of the given IDs. If the given ID is currently attached, it will be detached. Likewise, if it is currently detached, it will be attached:
$user->roles()->toggle([1, 2, 3]);
中間テーブルへの追加データ保存Saving Additional Data On A Pivot Table
多対多リレーションを操作する場合、save
メソッドの第2引数へ追加の中間テーブルの属性を指定できます。When working with a many-to-many relationship, the save
method accepts an array of additional intermediate table attributes as its second argument:
App\User::find(1)->roles()->save($role, ['expires' => $expires]);
中間テーブルのレコード更新Updating A Record On A Pivot Table
中間テーブルに存在している行を更新する必要がある場合は、updateExistingPivot
メソッドを使います。このメソッドは、中間テーブルの外部キーと更新する属性の配列を引数に取ります。If you need to update an existing row in your pivot table, you may use updateExistingPivot
method. This method accepts the pivot record foreign key and an array of attributes to update:
$user = App\User::find(1);
$user->roles()->updateExistingPivot($roleId, $attributes);
親のタイムスタンプの更新Touching Parent Timestamps
Comment
がPost
に所属しているように、あるモデルが他のモデルに所属(belongsTo
もしくはbelongsToMany
)しており、子のモデルが更新される時に親のタイムスタンプを更新できると便利なことがあります。たとえばComment
モデルが更新されたら、所有者のPost
のupdated_at
タイムスタンプを自動的に"touch"したい場合です。Eloquentなら簡単です。子のモデルにtouches
プロパティを追加しリレーション名を指定してください。When a model belongsTo
or belongsToMany
another model, such as a Comment
which belongs to a Post
, it is sometimes helpful to update the parent's timestamp when the child model is updated. For example, when a Comment
model is updated, you may want to automatically "touch" the updated_at
timestamp of the owning Post
. Eloquent makes it easy. Just add a touches
property containing the names of the relationships to the child model:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Comment extends Model
{
/**
* 全リレーションをtouch
*
* @var array
*/
protected $touches = ['post'];
/**
* ポストに所属しているコメント取得
*/
public function post()
{
return $this->belongsTo('App\Post');
}
}
これでComment
が更新されると、所有しているPost
のupdated_at
カラムも同時に更新され、これによりPost
モデルのどの時点のキャッシュを無効にするか判定できます。Now, when you update a Comment
, the owning Post
will have its updated_at
column updated as well, making it more convenient to know when to invalidate a cache of the Post
model:
$comment = App\Comment::find(1);
$comment->text = 'Edit to this comment!';
$comment->save();