【laravel7.x中文文档】模型关联

【laravel7.x中文文档】模型关联

Eloquent: 关联

[TOC]

简介

数据库表通常相互关联。例如，一篇博客文章可能有许多评论，或者一个订单对应一个下单用户。Eloquent 让这些关联的管理和使用变得简单，并支持多种类型的关联:

一对一
一对多
多对多
远程一对一
远程一对多
一对一（多态关联）
一对多（多态关联）
多对多（多态关联）

定义关联

Eloquent 关联在 Eloquent 模型类中以方法的形式呈现。如同 Eloquent 模型本身，关联也可以作为强大的查询语句构造器使用，提供了强大的链式调用和查询功能。例如，我们可以在 posts 关联的链式调用中附加一个约束条件：

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

不过在深入使用关联之前，让我们先学习如何定义每种关联类型。

注意：关系名称不能与属性名称冲突，因为这会导致您的模型不知道要解析哪一个。

一对一

一对一是最基本的关联关系。例如，一个 User 模型可能关联一个 Phone 模型。为了定义这个关联，我们要在 User 模型中写一个 phone 方法。在 phone 方法内部调用 hasOne 方法并返回其结果:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    /**
     * 获取与用户相关的电话记录。
     */
    public function phone()
    {
        return $this->hasOne('App\Phone');
    }
}

hasOne 方法的第一个参数是关联模型的类名。一旦定义了模型关联，我们就可以使用 Eloquent 的动态属性获得相关的记录。动态属性允许你访问关联方法就像访问模型中定义的属性一样：

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

Eloquent 会基于模型名决定外键名称。在这种情况下，会自动假设 Phone 模型有一个 user_id 外键。如果你想覆盖这个约定，可以传递第二个参数给 hasOne 方法：

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

另外，Eloquent 假设外键的值是与父级 id（或自定义 $primaryKey）列的值相匹配的。换句话说，Eloquent 将会在 Phone 记录的 user_id 列中查找与用户表的 id 列相匹配的值。如果您希望该关联使用 id 以外的自定义键名，则可以给 hasOne 方法传递第三个参数：

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

定义反向关联

我们已经能从 User 模型访问到 Phone 模型了。现在，让我们再在 Phone 模型上定义一个关联，这个关联能让我们访问到拥有该电话的 User 模型。我们可以使用与 hasOne 方法对应的 belongsTo 方法来定义反向关联：

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Phone extends Model
{
    /**
     * 获取拥有此电话的用户
     */
    public function user()
    {
        return $this->belongsTo('App\User');
    }
}

在上面的例子中， Eloquent 会尝试匹配 Phone 模型上的 user_id 至 User 模型上的 id。它是通过检查关系方法的名称并使用 _id 作为后缀名来确定默认外键名称的。但是，如果 Phone 模型的外键不是 user_id，那么可以将自定义键名作为第二个参数传递给 belongsTo 方法：

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

如果父级模型没有使用 id 作为主键，或者是希望用不同的字段来连接子级模型，则可以通过给 belongsTo 方法传递第三个参数的形式指定父级数据表的自定义键：

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

一对多

一对多关联用于定义单个模型拥有任意数量的其它关联模型。例如，一篇博客文章可能会有无限多条评论。正如其它所有的 Eloquent 关联一样，一对多关联的定义也是在 Eloquent 模型中写一个方法：

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

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

记住一点，Eloquent 将会自动确定 Comment 模型的外键属性。按照约定，Eloquent 将会使用所属模型名称的「snake case」形式，再加上 _id 后缀作为外键字段。因此，在上面这个例子中，Eloquent 将假定 Comment 对应到 Post 模型上的外键就是 post_id。

一旦关系被定义好以后，就可以通过访问 Post 模型的 comments 属性来获取评论的集合。记住，由于 Eloquent 提供了「动态属性」，所以我们可以像访问模型的属性一样访问关联方法：

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

foreach ($comments as $comment) {
    //
}

当然，由于所有的关联还可以作为查询语句构造器使用，因此你可以使用链式调用的方式，在 comments 方法上添加额外的约束条件：

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

正如 hasOne 方法一样，你也可以在使用 hasMany 方法的时候，通过传递额外参数来覆盖默认使用的外键与本地键：

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

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

一对多 (反向)

现在，我们已经能获得一篇文章的所有评论，接着再定义一个通过评论获得所属文章的关联关系。这个关联是 hasMany 关联的反向关联，需要在子级模型中使用 belongsTo 方法定义它：

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

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

这个关系定义好以后，我们就可以通过访问 Comment 模型的 post 这个「动态属性」来获取关联的 Post 模型了：

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

echo $comment->post->title;

在上面的例子中，Eloquent 会尝试用 Comment 模型的 post_id 与 Post 模型的 id 进行匹配。默认外键名是 Eloquent 依据关联名，并在关联名后加上 _再加上主键字段名作为后缀确定的。当然，如果 Comment 模型的外键不是 post_id ，那么可以将自定义键名作为第二个参数传递给 belongsTo 方法：

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

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

多对多

多对多关联比 hasOne 和 hasMany 关联稍微复杂些。举个例子，一个用户可以拥有很多种角色，同时这些角色也被其他用户共享。例如，许多用户可能都有「管理员」这个角色。

表结构

要定义这种关联，需要三个数据库表： users ，roles 和 role_user。role_user 表的命名是由关联的两个模型按照字母顺序来的，并且包含了 user_id 和 role_id 字段：

users
    id - integer
    name - string

roles
    id - integer
    name - string

role_user
    user_id - integer
    role_id - integer

模型结构

多对多关联通过调用 belongsToMany 这个内部方法返回的结果来定义，例如，我们在 User 模型中定义 roles 方法：

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    /**
     * 用户拥有的角色
     */
    public function roles()
    {
        return $this->belongsToMany('App\Role');
    }
}

一旦关联关系被定义后，你可以通过 roles 「动态属性」获取用户角色：

$user = App\User::find(1);

foreach ($user->roles as $role) {
    //
}

当然，像其它所有关联模型一样，你可以使用 roles 方法，利用链式调用对查询语句添加约束条件：

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

正如前面所提到的，为了确定关联连接表的表名，Eloquent 会按照字母顺序连接两个关联模型的名字。当然，你也可以不使用这种约定，传递第二个参数到 belongsToMany 方法即可：

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

除了自定义连接表的表名，你还可以通过传递额外的参数到 belongsToMany 方法来定义该表中字段的键名。第三个参数是定义此关联的模型在连接表里的外键名，第四个参数是另一个模型在连接表里的外键名：

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

定义反向关联

要定义多对多的反向关联，你只需要在关联模型中调用 belongsToMany 方法。我们在 Role 模型中定义 users 方法：

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Role extends Model
{
    /**
     * 拥有此角色的用户
     */
    public function users()
    {
        return $this->belongsToMany('App\User');
    }
}

如你所见，除了引入模型为 App\User 外，其它与在 User 模型中定义的完全一样。由于我们重用了 belongsToMany 方法，自定义连接表表名和自定义连接表里的键的字段名称在这里同样适用。

获取中间表字段

就如你刚才所了解的一样，多对多的关联关系需要一个中间表来提供支持， Eloquent 提供了一些有用的方法来和这张表进行交互。例如，假设我们的 User 对象关联了多个 Role 对象。在获得这些关联对象后，可以使用模型的 pivot 属性访问中间表的属性：

$user = App\User::find(1);

foreach ($user->roles as $role) {
    echo $role->pivot->created_at;
}

需要注意的是，我们获取的每个 Role 模型对象，都会被自动赋予 pivot 属性，它代表中间表的一个模型对象，并且可以像其他的 Eloquent 模型一样使用。

默认情况下，pivot 对象只包含两个关联模型的主键，如果你的中间表里还有其他额外字段，你必须在定义关联时明确指出：

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

如果你想让中间表自动维护 created_at 和 updated_at 时间戳，那么在定义关联时附加上 withTimestamps 方法即可：

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

自定义 `pivot` 属性名称

如前所述，来自中间表的属性可以使用 pivot 属性访问。但是，你可以自由定制此属性的名称，以便更好的反应其在应用中的用途。

例如，如果你的应用中包含可能订阅的用户，则用户与博客之间可能存在多对多的关系。如果是这种情况，你可能希望将中间表访问器命名为 subscription 取代 pivot 。这可以在定义关系时使用 as 方法完成：

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

一旦定义完成，你可以使用自定义名称访问中间表数据：

$users = User::with('podcasts')->get();

foreach ($users->flatMap->podcasts as $podcast) {
    echo $podcast->subscription->created_at;
}

通过中间表过滤关系

在定义关系时，你还可以使用 wherePivot 和 wherePivotIn 方法来过滤 belongsToMany 返回的结果：

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]);

定义中间表模型

如果你想定义一个自定义模型来表示关联关系中的中间表，可以在定义关联时调用 using 方法。自定义多对多中间表模型都必须扩展自 Illuminate\Database\Eloquent\Relations\Pivot 类，自定义多对多（多态）中间表模型必须继承 Illuminate\Database\Eloquent\Relations\MorphPivot 类。例如，我们在写 Role 模型的关联时，使用自定义中间表模型 RoleUser:

<?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 类：

<?php

namespace App;

use Illuminate\Database\Eloquent\Relations\Pivot;

class RoleUser extends Pivot
{
    //
}

你可以组合使用 using 和 withPivot 从中间表来检索列。例如，通过将列名传递给 withPivot 方法，就可以从 UserRole 中间表中检索出 created_by 和 updated_by 两列数据:

<?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',
                        ]);
    }
}

注意: Pivot 模型可能不使用 SoftDeletes 特性。如果您需要软删除数据关联记录，请考虑将您的数据关联模型转换为实际的 Eloquent 模型。

带有递增 ID 的自定义中继模型

如果你用一个自定义的中继模型定义了多对多的关系，而且这个中继模型拥有一个自增的主键，你应当确保这个自定义中继模型类中定义了一个 incrementing 属性其值为 true 。

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

远程一对一关系

远程一对一关联通过一个中间关联模型实现。
例如，如果每个供应商都有一个用户，并且每个用户与一个用户历史记录相关联，那么供应商可以通过用户访问用户的历史记录，让我们看看定义这种关系所需的数据库表：

users
    id - integer
    supplier_id - integer

suppliers
    id - integer

history
    id - integer
    user_id - integer

虽然 history 表不包含 supplier_id ，但 hasOneThrough 关系可以提供对用户历史记录的访问，以访问供应商模型。现在我们已经检查了关系的表结构，让我们在 Supplier 模型上定义相应的方法：

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Supplier extends Model
{
    /**
     * 用户的历史记录
     */
    public function userHistory()
    {
        return $this->hasOneThrough('App\History', 'App\User');
    }
}

传递给 hasOneThrough 方法的第一个参数是希望访问的模型名称，第二个参数是中间模型的名称。

当执行关联查询时，通常会使用 Eloquent 约定的外键名。如果你想要自定义关联的键，可以通过给 hasOneThrough 方法传递第三个和第四个参数实现，第三个参数表示中间模型的外键名，第四个参数表示最终模型的外键名。第五个参数表示本地键名，而第六个参数表示中间模型的本地键名：

class Supplier extends Model
{
    /**
     * 用户的历史记录
     */
    public function userHistory()
    {
        return $this->hasOneThrough(
            'App\History',
            'App\User',
            'supplier_id', // Foreign key on users table...
            'user_id', // Foreign key on history table...
            'id', // Local key on suppliers table...
            'id' // Local key on users table...
        );
    }
}

远程一对多关联

远程「一对多」关联提供了方便、简短的方式通过中间的关联来获得远层的关联。例如，一个 Country 模型可以通过中间的 User 模型获得多个 Post 模型。在这个例子中，你可以轻易地收集给定国家的所有博客文章。让我们来看看定义这种关联所需的数据表：

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->posts 访问到一个国家下所有的用户文章。为了完成这个查询，Eloquent 会先检查中间表 users 的 country_id 字段，找到所有匹配的用户 ID 后，使用这些 ID，在 posts 表中完成查找。

现在，我们已经知道了定义这种关联所需的数据表结构，接下来，让我们在 Country 模型中定义它：

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Country extends Model
{
    /**
     * 当前国家所有文章
     */
    public function posts()
    {
        return $this->hasManyThrough('App\Post', 'App\User');
    }
}

hasManyThrough 方法的第一个参数是我们最终希望访问的模型名称，而第二个参数是中间模型的名称。

当执行关联查询时，通常会使用 Eloquent 约定的外键名。如果你想要自定义关联的键，可以通过给 hasManyThrough 方法传递第三个和第四个参数实现，第三个参数表示中间模型的外键名，第四个参数表示最终模型的外键名。第五个参数表示本地键名，而第六个参数表示中间模型的本地键名：

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

多态关联

多态关联允许目标模型借助单个关联从属于多个模型。

一对一 (多态)

表结构

一对一多态关联与简单的一对一关联类似；不过，目标模型能够在一个关联上从属于多个模型。例如，博客 Post 和 User 可能共享一个关联到 Image 模型的关系。使用一对一多态关联允许使用一个唯一图片列表同时用于博客文章和用户账户。让我们先看看表结构：

posts
    id - integer
    name - string

users
    id - integer
    name - string

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

要特别留意 images 表的 imageable_id 和 imageable_type 列。 imageable_id 列包含文章或用户的 ID 值，而 imageable_type 列包含的则是父模型的类名。Eloquent 在访问 imageable 时使用 imageable_type 列来判断父模型的「类型」。

模型结构

接下来，再看看建立关联的模型定义：

<?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');
    }
}

获取关联

一旦定义了表和模型，就可以通过模型访问此关联。比如，要获取文章图片，可以使用 image 动态属性：

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

$image = $post->image;

还可以通过访问执行 morphTo 调用的方法名来从多态模型中获知父模型。在这个例子中，就是 Image 模型的 imageable 方法。所以，我们可以像动态属性那样访问这个方法：

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

$imageable = $image->imageable;

Image 模型的 imageable 关联将返回 Post 或 User 实例，其结果取决于图片属性哪个模型。

一对多（多态）

表结构

一对多多态关联与简单的一对多关联类似；不过，目标模型可以在一个关联中从属于多个模型。假设应用中的用户可以同时「评论」文章和视频。使用多态关联，可以用单个 comments 表同时满足这些情况。我们还是先来看看用来构建这种关联的表结构：

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');
    }
}

获取关联

一旦定义了数据库表和模型，就可以通过模型访问关联。例如，可以使用 comments 动态属性访问文章的全部评论：

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

foreach ($post->comments as $comment) {
    //
}

还可以通过访问执行 morphTo 调用的方法名来从多态模型获取其所属模型。在本例中，就是 Comment 模型的 commentable 方法：

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

$commentable = $comment->commentable;

Comment 模型的 commentable 关联将返回 Post 或 Video 实例，其结果取决于评论所属的模型。

多对多（多态）

表结构

多对多多态关联比 morphOne 和 morphMany 关联略微复杂一些。例如，博客 Post 和 Video 模型能够共享关联到 Tag 模型的多态关系。使用多对多多态关联允许使用一个唯一标签在博客文章和视频间共享。以下是多对多多态关联的表结构：

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

模型结构

接下来，在模型上定义关联。Post 和 Video 模型都有调用 Eloquent 基类上 morphToMany 方法的 tags 方法：

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    /**
     * 获取文章的所有标签
     */
    public function tags()
    {
        return $this->morphToMany('App\Tag', 'taggable');
    }
}

定义反向关联关系

下面，需要在 Tag 模型上为每个关联模型定义一个方法。在这个示例中，我们将会定义 posts 方法和 videos 方法：

<?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');
    }
}

获取关联

一旦定义了数据库表和模型，就可以通过模型访问关联。例如，可以使用 tags 动态属性访问文章的所有标签：

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

foreach ($post->tags as $tag) {
    //
}

还可以访问执行 morphedByMany 方法调用的方法名来从多态模型获取其所属模型。在这个示例中，就是 Tag 模型的 posts 或 videos 方法。可以像动态属性一样访问这些方法：

$tag = App\Tag::find(1);

foreach ($tag->videos as $video) {
    //
}

自定义多态类型

默认情况下， Laravel 使用完全限定类名存储关联模型类型。在上面的一对多示例中，因为 Comment 可能从属于一个 Post 或一个 Video，默认的 commentable_type 就将分别是 App\Post 或 App\Video。不过，你可能希望数据库与应用的内部结构解耦。在这种情况下，可以定义一个「morph 映射」来通知 Eloquent 使用自定义名称代替对应的类名：

use Illuminate\Database\Eloquent\Relations\Relation;

Relation::morphMap([
    'posts' => 'App\Post',
    'videos' => 'App\Video',
]);

可以在 AppServiceProvider 的 boot 函数中注册 morphMap，或者创建一个单独的服务提供者。

注意：在现有应用程序中添加「morph 映射」时，数据库中仍包含完全限定类的每个可变形 *_type 列值都需要转换为其「映射」名称。

查询关联

由于 Eloquent 关联的所有类型都通过方法定义，你可以调用这些方法，而无需真实执行关联查询。另外，所有 Eloquent 关联类型用作查询构造器，允许你在数据库上执行 SQL 之前，持续通过链式调用添加约束。

例如，假设一个博客系统的 User 模型有许多关联的 Post 模型：

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    /**
     * 获取该用户的所有文章
     */
    public function posts()
    {
        return $this->hasMany('App\Post');
    }
}

你可以查询 posts 关联，并为其添加额外的约束：

$user = App\User::find(1);

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

你可以在关联上使用任意查询构造器方法，请查阅查询构造器文档，学习那些对你有用的方法。

在关联之后链式添加 `orWhere` 条件

如上所示，你可以在查询关联时自由添加其他约束。但是，在将 orWhere 子句链接到关联时要小心，因为 orWhere 子句将在逻辑上与关联约束处于同一级别：

$user->posts()
        ->where('active', 1)
        ->orWhere('votes', '>=', 100)
        ->get();

// select * from posts
// where user_id = ? and active = 1 or votes >= 100

在大多数情况下，你可以使用约束组在括号中对条件检查进行逻辑分组：

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)

关联方法 Vs. 动态属性

如果不需要向 Eloquent 关联查询添加额外的约束，可以像属性一样访问关联。例如，继续使用 User 和 Post 示例模型，可以这样访问用户的全部文章：

$user = App\User::find(1);

foreach ($user->posts as $post) {
    //
}

动态属性是「懒加载」的，这意味着它们仅在你真实访问关联数据时才被载入。因此，开发者经常使用预加载预先加载那些他们确知在载入模型后将访问的关联。对载入模型关联中必定被执行的 SQL 查询而言，预加载显著减少了查询的执行次数。

查询已存在的关联

在访问模型记录时，可能希望基于关联的存在限制查询结果。比如想要获取至少存在一条评论的所有文章，可以通过给 has 和 orHas 方法传递关联名称来实现：

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

还可以指定运算符和数量进一步自定义查询：

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

还可以用「点」语法构造嵌套的 has 语句。比如，可以获取拥有至少一条评论和投票的文章：

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

如果需要更多功能，可以使用 whereHas 和 orWhereHas 方法将「where」条件放到 has 查询上。这些方法允许你向关联加入自定义约束，比如检查评论内容：

use Illuminate\Database\Eloquent\Builder;

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

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

查询不存在的关联

在访问模型记录时，可能希望基于关联不存在来限制查询结果。假设想要获取不存在任何评论的文章，可以通过向 doesntHave 和 orDoesntHave 方法传递关联名称来实现：

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

如果需要更多功能，可以使用 whereDoesntHave 和 orWhereDoesntHave 方法将「where」条件加到 doesntHave 查询上。这些方法允许你向关联加入自定义限制，比如检测评论内容：

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', 0);
})->get();

多态关联查询

要查询 MorphTo 关联的存在，可以使用 whereHasMorph 方法及其相应的方法：

use Illuminate\Database\Eloquent\Builder;

// 查询与帖子或视频相关并且标题包含 foo 的评论...
$comments = App\Comment::whereHasMorph(
    'commentable',
    ['App\Post', 'App\Video'],
    function (Builder $query) {
        $query->where('title', 'like', 'foo%');
    }
)->get();

// 查询与帖子相关的评论，标题不像 foo％...
$comments = App\Comment::whereDoesntHaveMorph(
    'commentable',
    'App\Post',
    function (Builder $query) {
        $query->where('title', 'like', 'foo%');
    }
)->get();

你可以使用 $type 参数根据相关模型添加不同的约束：

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 从数据库中查询所有可能的多态类型，而不是传递可能的多态模型数组。 Laravel 将执行其他查询以执行此操作：

use Illuminate\Database\Eloquent\Builder;

$comments = App\Comment::whereHasMorph('commentable', '*', function (Builder $query) {
    $query->where('title', 'like', 'foo%');
})->get();

【【laravel7.x中文文档】模型关联隶属于分类： php laravel

它起初由本站用户:刘欣Eden于3年前创建。

它被收录于如下合集： Laravel7中文文档

该内容的链接是：

【laravel7.x中文文档】 模型关联

Eloquent: 关联

简介

定义关联

一对一

定义反向关联

一对多

一对多 (反向)

多对多

表结构

模型结构

定义反向关联

获取中间表字段

自定义 pivot 属性名称

通过中间表过滤关系

定义中间表模型

带有递增 ID 的自定义中继模型

远程一对一关系

远程一对多关联

多态关联

一对一 (多态)

表结构

模型结构

获取关联

一对多（多态）

表结构

模型结构

获取关联

多对多（多态）

表结构

模型结构

定义反向关联关系

获取关联

自定义多态类型

查询关联

在关联之后链式添加 orWhere 条件

关联方法 Vs. 动态属性

查询已存在的关联

查询不存在的关联

多态关联查询

【laravel7.x中文文档】模型关联

自定义 `pivot` 属性名称

在关联之后链式添加 `orWhere` 条件