澳门正规赌博十大网站-澳门游戏网站
做最好的网站

关联模型,laravel学习教程之关联模型

1.概念关联模型

数据库中的表平日性的关系另外的表。举例,一个博客小说能够有无数的评说,或许一个订单会涉及三个用户。Eloquent 使管理和合营那个关系变的那些的轻易,並且援助两种不相同类型的关系:

Eloquent: 关联模型

图片 1

  • 一对一
  • 一对多
  • 多对多
  • 远程一对多
  • 多态关联
  • 多态多对多关系

简介

2.用到关联模型

Eloquent 关联能够像定义方法同样在 Eloquent 模型类中开始展览定义。同一时候,它就如 Eloquent 模型本人一样也提供了强有力的查询生成器。那允许涉及模型能够链式的实行查询技巧。比方:

数据库中的表平时性的关联其余的表。举例,一个博客小说能够有众多的评头品足,恐怕一个订单会提到一个用户。Eloquent 使处理和搭档这么些涉及变的老大的轻便,而且帮衬二种不相同类型的关联:

D('BlogRelation')->relation(true)->add($data);
$user->posts()->where('active', 1)->get();

    一对一

 

唯独,在更深透的应用关联在此之前,让大家先来上学一下怎么着定义种种类型的涉嫌。

    一对多


一对一

一定的关联是最基础的关系。比方,二个 User 模型或许涉及四个 Phone。大家须求在 User 模型上放置三个 phone 方法来定义这种关联。phone 方法应该回到一个基类 Eloquent 模型上 hasOne 方法的结果:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class User extends Model{ /** * Get the phone record associated with the user. */ public function phone() { return $this->hasOne('AppPhone'); }}

传递到 hasOne 方法的第三个参数应该是关乎模型的称号。一旦涉及被定义完结,大家能够使用 Eloquent 的动态属性来拜见关联模型的笔录。动态属性允许你拜见关联函数,就如它们是概念在模型中的属性同样:

$phone = User::find->phone;

Eloquent 假定所提到的外键是基于模型的称谓的。在那一个前提下,Phone 模型会自行的例如其持有三个 user_id 外键。就算您期望修改那些惯例,你能够传递第4个参数到 hasOne 方法中:

return $this->hasOne('AppPhone', 'foreign_key');

另外,Eloquent 也会假定外键应该在其上层模型上装有贰个卓殊的 id(只怕自定义的 $primaryKey)值。换句话说,Eloquent 会查询 Phone 记录中的 user_id 列所对应的用户的 id 列的记录。假设您期望关联应用 id 以外的值,你能够传递第三个参数到 hasOne 方法来内定自定义的键:

return $this->hasOne('AppPhone', 'foreign_key', 'local_key');

概念相对的涉及

那么,大家可以从我们的 User 中访问 Phone 模型。未来,让我们在 Phone 模型上定义一个关系,让我们得以从 Phone 模型中拜会其所属的 User。大家采纳 belongsTo 方法来定义 hasOne 相对的涉嫌:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class Phone extends Model{ /** * Get the user that owns the phone. */ public function user() { return $this->belongsTo('AppUser'); }}

在上面的事例中,Eloquent 将会尝试从 Phone 模型中的 user_id 字段中相配查找 id 相同的 User。Eloquent 会依靠所关联的模型的蛇形命名和 _id 来假定私下认可的外键名。事实上,即便在 Phone 模型上的外键不是 user_id,那么您可以传递自定义的外键名到 belongsTo 方法的第3个参数:

/** * Get the user that owns the phone. */public function user(){ return $this->belongsTo('AppUser', 'foreign_key');}

要是你的上级模型并不曾应用 id 作为主键名,恐怕你希望属下模型关联四个两样的列。你能够传递第多个参数到 belongsTo 方法来内定上级模型表中的自定义键:

/** * Get the user that owns the phone. */public function user(){ return $this->belongsTo('AppUser', 'foreign_key', 'other_key');}

    多对多

一对多

二个一对多的涉及平常用来定义二个模子拥有别样随便数目标模型。例如,叁个博客小说可以有所比相当多条研讨。就如其余的 Eloquent 关联一样,一对多涉及在 Eloquent 模型中经过艺术来进展定义:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class Post extends Model{ /** * Get the comments for the blog post. */ public function comments() { return $this->hasMany('AppComment'); }}

记住,Eloquent 会自动的依附 Comment 模型来判别合适的外键。依赖惯例,Eloquent 会使用自身模型的蛇形命名和 _id 来作为外键。所以,在那个例子中,Eloquent 会假定 Comment 模型的外键是 post_id

假若涉及定义完毕未来,我们能够通过 comments 属性来访谈具备关乎的评头品足的汇集。记住,由于 Eloquent 提供了动态属性,我们得以对事关函数举行访谈,如同他们是在模型中定义的属性一样:

$comments = AppPost::find->comments;foreach ($comments as $comment) { //}

本来,由于具备的关系都提供了询问生成器的效应,所以您能够在调用 comments 方法时继续的增进部分限制条件,你能够由此链式的调用进行查询条件的拉长:

$comments = AppPost::find->comments()->where('title', 'foo')->first();

就像 hasOne 方法,你能够因此增加额外的参数到 hasMany 方法中来重新载入参数外键和主键:

return $this->hasMany('AppComment', 'foreign_key');return $this->hasMany('AppComment', 'foreign_key', 'local_key');

概念相对的涉嫌

当今大家得以访谈小说中兼有的褒贬了,让大家为评价定义贰个涉及使其可以访谈它的上层小说模型。为了定义三个 hasMany 绝对的涉及,你供给在下层模型中定义八个提到方法并调用 belongsTo 方法:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class Comment extends Model{ /** * Get the post that owns the comment. */ public function post() { return $this->belongsTo('AppPost'); }}

假如涉及被定义达成,大家就足以经过 Comment 模型的 post 动态属性来搜索到其对应的 Post 模型:

$comment = AppComment::find;echo $comment->post->title;

在地点的例证中,Eloquent 会尝试从 Comment 模型中的 post_id 字段寻觅与其相对应 idPost 模型。Eloquent 会使用关联模型的蛇形命名和 _id 来作为暗许的外键。假诺 Comment 模型的外键不是 post_id,你能够传递八个自定义的键名到 belongsTo 方法的第一个参数:

/** * Get the post that owns the comment. */public function post(){ return $this->belongsTo('AppPost', 'foreign_key');}

一旦上层模型并从未选取 id 作为主键,或然你想在下层模型中涉嫌别的的列,你能够传递第二个参数到 belongsTo 方法中:

/** * Get the post that owns the comment. */public function post(){ return $this->belongsTo('AppPost', 'foreign_key', 'other_key');}

    远程一对多

多对多

多对多的涉及比 hasOnehasMany 关联要略微复杂一些。假若贰个用户具备多个角色,而剧中人物又足以被别的的用户所分享。举个例子,多个用户能够具备管理员的剧中人物。要是定义这种关系,大家须要定义多少个数据库表:users关联模型,laravel学习教程之关联模型。,roles,和 role_userrole_user关联模型,laravel学习教程之关联模型。 表的命名是以相关联的八个模型数据表来遵照字母逐个命名,何况表中带有了 user_idrole_id关联模型,laravel学习教程之关联模型。 列。

多对多涉及须求编写制定二个方法调用基础 Eloquent 类 belongsToMany 方法。比方,让我们在 User 模型中定义二个 roles 方法:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class User extends Model{ /** * The roles that belong to the user. */ public function roles() { return $this->belongsToMany('AppRole'); }}

关联模型,laravel学习教程之关联模型。举个例子涉及被定义,你能够由此 roles 动态属性来做客用户的剧中人物:

$user = AppUser::find;foreach ($user->roles as $role) { //}

当然,就好像别的项目标涉及,你可以调用 roles 方法並且链式调用查询条件:

$roles = AppUser::find->roles()->orderBy->get();

就如先前所提到的,Eloquent 会面併三个关系模型并依据字母顺序实行命名。当然你也能够放肆的重写这么些约定,你能够传递第一个参数到 belongsToMany 方法:

return $this->belongsToMany('AppRole', 'role_user');

除此而外自定义合併数据表的名号之外,你也足以透过往 belongsToMany 方法传传递额外参数来自定义数据表里的键的字段名称。第多少个参数是您定义在关系中模型外键的名目。第八个参数则是你要联合的模子外键的称号:

return $this->belongsToMany('AppRole', 'role_user', 'user_id', 'role_id');

概念绝对关联

你只需求在相呼应的涉嫌模型里放置任何的办法来调用 belongsToMany 方法就能够定义相对关联。继续我们地点的用户剧中人物示例,让大家在 Role 模型中定义八个 users 方法:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class Role extends Model{ /** * The users that belongs to the role. */ public function users() { return $this->belongsToMany('AppUser'); }}

仿佛您所见到的,这几个关系的概念与用户的关系定义完全一样。因为我们重新的选拔了 belongsToMany 方法,当定义相对于多对多的关系时,全体常用的自定义数据表和键的选项都以可用的。

招来中间表字段

正如您曾经掌握到的。定义多对多的关系必要引入贰当中间表。Eloquent 提供了二种拾贰分有扶持的主意来与这么些表实行交互。譬喻,让大家只要我们的 User 对象关系到了众多 Role 对象。在访谈那么些关乎对象时,大家得以由此在模型上利用 pivot 属性来访谈中间表:

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

只顾大家抽取的各样 Role 对象,都会被机关的分红 pivot 属性。那性子情满含了一个表示中间表的模子,並且能够像另外 Eloquent 模型同样被运用。

暗许的,独有模型的键会被 pivot 对象提供,假诺你的中间表包罗了额外的习性,你不能够不在概念关联时钦点它们:

return $this->belongsToMany('AppRole')->withPivot('column1', 'column2');

一经你想要中间表自动拥戴 created_atupdated_at 时间戳,你能够在概念关联时行使 withTimestamps 方法:

return $this->belongsToMany('AppRole')->withTimestamps();

经过中间表字段过滤关系

你能够经过在概念关联时使用 wherePrivotwherePivotIn 方法来在回到的结果中实行过滤:

return $this->belongsToMany('AppRole')->wherePivot('approved', 1);return $this->belongsToMany('AppRole')->wherePivotIn('approved', [1, 2]);

    多态关联

远程一对多

远程一对多涉及提供了简便便捷的法子通过中间关联件来走访远端的涉及。举个例子,八个 Country 模型应该经过 User 模型能够具备广大的 Post 模型。在这一个事例中,你能够特别轻巧的就招来出三个国度中的全数的作品。让咱们来看一下定义这几个涉嫌所急需的表:

countries id - integer name - stringusers id - integer country_id - integer name - stringposts id - integer user_id - integer title - string

远端的 posts 并未包括 country_id 列,hasManyThrough 关联能够由此 $country->posts 来访问一个国家的稿子。为了实行那一个查询,Eloquent 会通过中间表 userscountry_id 来检索 posts 表中用户 ID 相相称的笔录。

当今大家已经分明了关联表的构造,那么让咱们来在 Country 模型上定义关联:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class Country extends Model{ /** * Get all of the posts for the country. */ public function posts() { return $this->hasManyThrough('AppPost', 'AppUser'); }}

传递到 hasManyThrough 方法的第一个参数是我们最终想要访谈到的模子,而第三个参数则是中间层的模子名称。

当使用关联合检查询时,日常 Eloquent 会遵守外键约定。如若你希望对关系的键实行自定义,你能够传递第三和第多少个参数到 hasManyThrough 方法。第2个参数是中间层模型的外键名称,第八个参数是最终想要获取的模子中的所对应的中间层的外键, 而第三个参数则是现阶段模型的主键:

class Country extends Model{ public function posts() { return $this->hasManyThrough( 'AppPost', 'AppUser', 'country_id', 'user_id', 'id' ); }}

    多态多对多关系

多态关联

表结构

多态关联允许几个模型在单个关联合中学从属四个或四个其余模型。比如,想象一下选拔中的用户能够欣赏作品及其商量。若是采用多态关联,那么你就可以利用三个独门的 likes 表来涉及那五个情景。首先,让大家鲜明定义这种关系所供给的表结构:

posts id - integer title - string body - textcomments id - integer post_id - integer body - textlikes id - integer likeable_id - integer likeable_type - string

你必要小心到的多个在 likes 表中重大的字段 likeable_idlikeable_typelikeable_id 字段会包括文章可能议论的 ID 值,而 likeable_type 字段会蕴含其所属的模型的类名。likeable_type 正是当访谈 likeable 关联时 ORM 用来推断所属的模子是哪个品种。

模型结构

随之,让我们检查一下那些关系所要求的模型定义:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class like extends Model{ /** * Get all of the owning likeable models. */ public function likeable() { return $this->morphTo(); }}class Post extends Model{ /** * Get all of the post's likes. */ public function likes() { return $this->morphMany('AppLike', 'likeable'); }}class Comment extends Model{ /** * Get all of the comment's likes. */ public function likes() { return $this->morphMany('AppLike', 'likeable'); }}

获取多态关联

借使数据库表和模型都定义完结,你就可以在你的模型中做客这一个涉嫌。例如,你能够选取 likes 动态属性来访问小说中具有涉及的 likes 模型:

$post = AppPost::find;foreach ($post->likes as $like) { //}

您也可以经过在模型上调用提供 morphTo 的点子来收获多态模型其关联全数者。在上头的例子中,指的正是 Like 模型中的 likeable 方法。所以,大家能够像使用动态属性同样接纳办法来张开拜访:

$like = AppLike::find;$likeable = $like->likeable;

Like 模型的 likeable 关联将会回去二个 Post 或者 Comment 实例,这取决其所属者的类别。

自定义多态类型

私下认可的,Laravel 会使用包完全限定类名来存款和储蓄所涉嫌模型的品种。比如,上边的事例中 Like 能够属于 Post 或者 Comment。默认的 likeable_type 应该是 AppPost 或者 AppComment。事实上,你只怕希望从你的应用程序的内部结构分离数据库。在这一个例子中,你能够定义贰个涉嫌的多态映射来携带Eloquent 使用模型关联的表名称来顶替类名:

use IlluminateDatabaseEloquentRelationsRelation;Relation::morphMap([ AppPost::class, AppComment::class,]);

依旧,你能够钦命一个自定的字符串与种种模型进行关联:

use IlluminateDatabaseEloquentRelationsRelation;Relation::morphMap([ 'posts' => AppPost::class, 'likes' => AppLike::class,]);

您能够在你的 AppServiceProvider 恐怕三个分其余劳动提供者的 boot 方法中登记你的 morphMap

概念关联

多态多对多关系

表结构

除去古板的多态关联,你也足以定义多对多的多态关联。例如,一个博客的 PostVideo 模型应该能够分享一个多态关联的 Tag 模型。使用多对多的多态关联能够允许你的博客小说和录制能够分享独特标签的单个列表。首先,让大家来看一下表结构:

posts id - integer name - stringvideos id - integer name - stringtags id - integer name - stringtaggables tag_id - integer taggable_id - integer taggable_type - string

模型结构

继而,大家来定义模型中的关联。PostVideo 模型将都会含有调用基础 Eloquent 类的 morphToMany 方法的 tags 方法:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class Post extends Model{ /** * Get all of the tags for the post. */ public function tags() { return $this->morphToMany('AppTag', 'taggable'); }}

概念相对的涉嫌

接着,在 Tag 模型中,你应为持有涉及模型定义相应的主意。所以,在这几个例子中,大家将定义 posts 方法和 videos 方法:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class Tag extends Model{ /** * Get all of the posts that are assigned this tag. */ public function posts() { return $this->morphedByMany('AppPost', 'taggable'); } /** * Get all of the videos that are assigned this tag. */ public function videos() { return $this->morphedByMany('AppVideo', 'taggable'); }}

赢得涉及

当定义完毕数据表和模型之后,你就足以经过模型来访谈其关联。比方,你能够轻便的行使 tags 动态属性来拜谒文章的富有标签模型:

$post = AppPost::find;foreach ($post->tags as $tag) { //}

您也足以通过拜望模型中提供实施 morphedByMany 方法的不二秘诀来博取涉及模型的所属模型。在上边的事例中,便是 Tag 模型上的 posts 或者 videos 方法。所以,你能够像动态属性一样访谈那些艺术:

$tab = AppTag::find;foreach ($tag->videos as $video) { //}

出于具备的 Eloquent 关联类型都是由此艺术定义的,所以你能够调用这个措施来获取所涉嫌的模子的实例而没有需求实际的施行关联合检查询。其余,全部的 Eloquent 关联也都提供了询问生成器服务,那允许你能够三番五次的链式推行查询操作。

比方,想象一下博客系统中 User 模型拥有广大 Post 关联的模子:

<?phnamespace App;use IlluminateDatabaseEloquentModel;class User extends Model{ /** * Get all of the posts for the user. */ public function posts() { return $this->hasMany('AppPost'); }}

您能够查询 posts 关联的还要足够一些附加的查询约束:

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

你应当小心到了,你能够在关系中使用别的的查询生成器的不二秘技。

关系方法 Vs. 动态属性

设若你无需在张开 Eloquent 关联合检查询时增添额外的牢笼,你能够轻便的像它的性质一样进行访问。比方,大家三番两次行使 UserPost 示例模型。大家能够像这么来访谈用户的有着小说:

$user = AppUser::find;foreach ($user->posts as $post) { //}

动态属性是惰性加载的,那意味在你其实访谈他们前边,其涉嫌数据是不会加载的。正因为这么,开荒的时候常见选择预加载来张开加载一些快要用到的关系模型。预加载须要必须加载一个模型的涉嫌,那实惠的缩减了询问的次数。

查询关联是还是不是存在

当访谈一个模型的记录时,你大概会希望基于关联的记录是不是存在来对结果进行界定。例如,想象一下您期望猎取最少有一条争辩的博客文章。你能够传递关联的名目到 has 方法来做那一个:

// Retrieve all posts that have at least one comment...$posts = AppPost::has('comments')->get();

你也能够钦命操作符,和多少来更是定制查询:

// Retrieve all posts that have three or more comments...$posts = Post::has('comments', '>=', 3)->get();

您也能够选取 . 语法来布局嵌套的 has 语句。比如,你能够获得具有包括至少一条商讨和投票的小说:

// Retrieve all posts that hava at least one comment with votes...$posts = Post::has('comments.votes')->get();

一经您须要更高的操纵,你能够运用 whereHasorWhereHas 方法来在 has 查询中插入 where 子句。那几个形式允许你为关联实行自定义的羁绊查询。譬如检查探究的原委:

// Retrieve all posts with at least one comment containing words like foo%$posts = Post::whereHas('comments', function  { $query->where('content', 'like', 'foo%'); })->get();

计算关联结果

比如您期望计算关联的结果而不实际的加载它们,你能够利用 withCount 方法,那就要您的结果模型中增加 {relation}_count 列。比如:

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

你也足以况兼招来八个涉及的总括,以及丰裕询问约束:

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

Eloquent 关联能够像定义方法同样在 Eloquent 模型类中展开定义。相同的时间,它似乎 Eloquent 模型本人同样也提供了强有力的询问生成器。这允许涉及模型能够链式的实践查询工夫。举例:

预加载

当通过质量访谈 Eloquent 关联时,该关联的数据会被推移加载。那意味该关联数据只有在你实际的拜望属性时才会进展加载。事实上,Eloquent 能够在上层模型中二遍性预加载的。预加载有效制止了 N 1 的查找难题。要表明 N 1 搜索难点,大家能够来看多少个 Author 关联 Book 的示例:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class Book extends Model{ /** * Get the author that wrote the book. */ public function author() { return $this->belongsTo('AppAuthor'); }}

当今,让大家探究全部的书籍和他们的撰稿人:

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

其一循环会奉行贰次搜索回装有的图书,接着每本书会运作一遍搜索小编的操作。所以,如果咱们具备25 本书,那么循环将会进展 26 次查询:1 次询问全部的书籍,贰拾贰回查询相关书籍的小编。

特别幸运的,大家得以选拔预加载来将查询有效的垄断(monopoly)在 2 次。当查问时,使用 with 方法来内定关联的预加载:

$books = AppBook::with->get();foreach ($books as $book) { echo $book->author->name;}

对此这么些操作,只会实施多少个查询:

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

预加载多少个事关

不经常候你或者供给在七个操作中预加载几个事关,你只必要传递额外的参数到 with 方法中就足以:

$books = AppBook::with('author', 'publisher')->get();

嵌套的预加载

你能够利用 . 语法来加载嵌套的关联。例如,让我们在多少个 Eloquent 语句中壹次加载全部书籍的撰稿人以及小编的遗骸通讯簿:

$books = AppBook::with('author.contacts')->get();
$user->posts()->where('active', 1)->get();

预加载约束

奇迹你大概希望预加载一些关乎,不过也急需对预加载查询钦赐额外的自律,这里有个示范:

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

在那一个事例中,Eloquent 会值预加载作品的 title 列包含 first 单词的笔录。当然,你也能够调用其余查询生成器可用的主意:

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

不过,在更通透到底的使用关联在此以前,让大家先来读书一下怎么着定义各连串型的关联。

延迟预加载

临时候你大概需求在上层模型被拿走后才预加载其涉嫌。当您必要来动态调控是或不是加载关联模型时尤其有效:

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

假定你必要对预加载做一些查询约束,你能够传递 Closureload 方法:

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

Save 方法

Eloquent 提供了有助于的法子来为模型加上多少个关乎。例如,也许你须要为 Post 模型新添三个 Comment。除了手动的装置 Commentpost_id 属性,你也能够平素在事关模型中调用 save 方法来插入 Comment:

$comment = new AppComment(['message' => 'A new comment.']);$post = AppPost::find;$post->comments()->save;

细心上边大家并从未运用关联模型的动态属性的点子来访谈 comments,而是选用 comments 方法的花样来收获涉及模型的实例。save 方法会自动的增进相应的 post_id 值到新的 Comment 模型上。

纵然你必要叁回增加多少个涉及模型,你必要运用 saveMany 方法:

$post = AppPost::find;$post->comments()->saveMany([ new AppComment(['message' => 'A new comment.']), new AppComment(['message' => 'Another comment.']),]);

Save & 多对多涉及

当与多对多涉及互动时,save 方法接收壹当中间层表属性的额外参数数组作为第2个参数:

AppUser::find->roles()->save($role, ['expires' => $expires]);

Create 方法

除了 savesaveMany 方法之外,你也足以运用 create 方法,它能够收到属性组成的数组,创立二个模型何况将其积存到数据库。那一回,savecreate 方法的界别是 save 接收一个完好无损的 Eloquent 模型实例,而 create 接收的是三个原生的 PHP array:

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

在使用 create 方法在此以前,你应当保障已经阅读了品质的 批量赋值文书档案。

立异从属关联模型

当更新贰个 belongsTo 关联时,你应有利用 associate 方法。那一个方法会在下层模型中设置外键:

$account = AppAccount::find;$user->account()->associate;$user->save();

当删除 belongsTo 关联时,你应当运用 dissociate 方法,该方法会重新恢复设置下层模型所涉及的外键:

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

一对一

多对多关系

附加 / 抽离

当使用多对多关系时,Eloquent 提供了某个优良的救助方法来更有益的治本关系模型。比如,让大家想像一下用户能够有无数剧中人物同一时间剧中人物能够有众多用户。你能够选拔 attach 方法来附加一个剧中人物到用户同期在中间表中投入那条记下:

$user = AppUser::find;$user->roles()->attach;

当附加关联到模型时,你也得以传递三个分包额外数据的数组来将其增多到中间表中:

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

理当如此,不时候你大概供给从用户中除去一个角色。你可以应用 detach 方法来删除多对多涉及的记录。datech 方法将从中间表中删除相应的笔录。可是,除了中间表,别的七个模型的笔录都还大概会被保存:

// Detach a single role from the user...$user->roles()->detach;// Detach all roles from the user...$user->roles()->detach();

为了进一步的简便,attachdetach 也得以吸取 IDs 所组成的数组作为输入:

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

立异中间表的记录只要你须要更新中间表中留存的行,你能够选拔 updateExistingPivot 方法:

$user = AppUser::find;$user->roles()->updateExistingPivot($roleId, $attributes);

福利的同台

您也足以接纳 sync 方法来营造多对多的关联。sync 方法接收放置中间表 IDs 所组成的数组。率性 IDs 若无在所给定的数组中,那么其将会从中间表中开展删减。所以,在操作达成现在,唯有存在于给定数组里的 IDs 才会存在于中间表中:

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

你也能够况兼传递额外的中间表的键值对:

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

联合浮动上层模型时间戳

当多个模子 belongsTo 或者 belongsToMany 其它三个模申时,举个例子 Comment 从属于 Post,那对下层模型更新时相同的时候须要更新上层模型的光阴戳时很有赞助。比方,当 Comment 模型更新了,你想要自动的创新其所属的 Post 模型的 updated_at 时间戳。Eloquent 使之变的非常轻巧。你只需求在下层模型中增加三个 touches 属性来含有关联的称号就足以了:

<?phpnamespace App;use IlluminateDatabaseEloquentModel;class Comment extends Model{ /** * All of the relationships to be touched. * * @var array */ protected $touches = ['post']; /** * Get the post that the comment belongs to. */ public function post() { return $this->belongsTo('AppPost'); }}

明天,当您更新 Comment 时,其所属的 Post 将会同时更新 updated_at 列:

$comment = AppComment::find;$comment->text = 'Edit to this comment!';$comment->save();

一定的关联是最基础的关系。比方,一个 User模型大概涉嫌一个 Phone。大家须求在 User模型上停放二个 phone办法来定义这种关联。phone艺术应该回到二个基类 Eloquent 模型上 hasOne方法的结果:

<?php

namespace App;

use IlluminateDatabaseEloquentModel;

class User extends Model
{
 /**
  * Get the phone record associated with the user.
  */
 public function phone()
 {
  return $this->hasOne('AppPhone');
 }
}

传递到 hasOne艺术的率先个参数应该是事关模型的称谓。一旦涉及被定义完结,大家能够运用 Eloquent 的动态属性来拜望关联模型的笔录。动态属性允许你拜望关联函数,就如它们是概念在模型中的属性同样:

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

Eloquent 假定所涉嫌的外键是依靠模型的名指标。在那一个前提下,Phone模型会活动的譬喻其有着多个 user_id外键。假设您期望修改这些规矩,你能够传递第贰个参数到 hasOne方法中:

return $this->hasOne('AppPhone', 'foreign_key');

别的,Eloquent 也会假定外键应该在其上层模型上富有多少个十一分的 id(大概自定义的 $primaryKey)值。换句话说,Eloquent 会查询 Phone记录中的 user_id 列所对应的用户的 id列的记录。如若你希望关联应用 id以外的值,你可以传递第八个参数到 hasOne措施来内定自定义的键:

return $this->hasOne('AppPhone', 'foreign_key', 'local_key');

概念相对的涉及

那正是说,我们能够从大家的 User中访问 Phone模型。现在,让大家在 Phone模型上定义八个关联,让大家得以从 Phone模型中访问其所属的 User。大家选择 belongsTo办法来定义 hasOne相对的关系:

<?php

namespace App;

use IlluminateDatabaseEloquentModel;

class Phone extends Model
{
 /**
  * Get the user that owns the phone.
  */
 public function user()
 {
  return $this->belongsTo('AppUser');
 }
}

在上头的例证中,Eloquent 将会尝试从 Phone模型中的 user_id字段中相配查找 id相同的 UserEloquent会依赖所关联的模子的蛇形命名和 _id 来假定默许的外键名。事实上,借使在 Phone模型上的外键不是 user_id,那么你能够传递自定义的外键名到 belongsTo措施的第一个参数:

/**
 * Get the user that owns the phone.
 */
public function user()
{
 return $this->belongsTo('AppUser', 'foreign_key');
}

假使您的顶头上司模型并从未运用 id作为主键名,或许您愿意属下模型关联三个见仁见智的列。你能够传递第3个参数到 belongsTo办法来钦命上级模型表中的自定义键:

/**
 * Get the user that owns the phone.
 */
public function user()
{
 return $this->belongsTo('AppUser', 'foreign_key', 'other_key');
}

一对多

一个一对多的涉嫌平日用来定义二个模型具有别样随便数目标模子。举个例子,多少个博客作品能够具备众多条辩论。仿佛任何的 Eloquent 关联一样,一对多关系在 Eloquent 模型中通过措施来实行定义:

<?php

namespace App;

use IlluminateDatabaseEloquentModel;

class Post extends Model
{
 /**
  * Get the comments for the blog post.
  */
 public function comments()
 {
  return $this->hasMany('AppComment');
 }
}

切记,Eloquent 会自动的基于 Comment模型来剖断合适的外键。依靠惯例,Eloquent会动用自个儿模型的蛇形命名和_id来作为外键。所以,在这么些例子中,Eloquent会假定 Comment模型的外键是 post_id

若果涉及定义实现之后,大家能够通过 comments属性来访谈具备关乎的评介的聚焦。记住,由于 Eloquent提供了动态属性,大家能够对关乎函数举行寻访,就如她们是在模型中定义的质量同样:

$comments = AppPost::find(1)->comments;

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

道理当然是这样的,由于全部的涉嫌都提供了查询生成器的效劳,所以你可以在调用 comments情势时继续的拉长有的限制规范,你能够经过链式的调用进行询问条件的丰富:

$comments = AppPost::find(1)->comments()->where('title', 'foo')->first();

就像 hasOne艺术,你能够通过增多额外的参数到 hasMany方法中来重新恢复设置外键和主键:

return $this->hasMany('AppComment', 'foreign_key');

return $this->hasMany('AppComment', 'foreign_key', 'local_key');

概念相对的关联

今昔大家能够访问作品中具有的评说了,让大家为评价定义一个涉及使其可以访问它的上层小说模型。为了定义二个 hasMany相持的关联,你需求在下层模型中定义五个提到方法并调用 belongsTo方法:

<?php

namespace App;

use IlluminateDatabaseEloquentModel;

class Comment extends Model
{
 /**
  * Get the post that owns the comment.
  */
 public function post()
 {
  return $this->belongsTo('AppPost');
 }
}

若是涉及被定义达成,大家即可透过 Comment模型的 post动态属性来寻找到其相应的 Post模型:

$comment = AppComment::find(1);

echo $comment->post->title;

在地方的例证中,Eloquent会尝试从 Comment模型中的 post_id字段检索与其相对应 idPost模型。Eloquent会使用关联模型的蛇形命名和_id 来作为暗中认可的外键。假使 Comment模型的外键不是 post_id,你能够传递一个自定义的键名到 belongsTo方法的第4个参数:

/**
 * Get the post that owns the comment.
 */
public function post()
{
 return $this->belongsTo('AppPost', 'foreign_key');
}

要是上层模型并不曾利用 id 作为主键,也许你想在下层模型中提到其余的列,你能够传递第几个参数到 belongsTo 方法中:

/**
 * Get the post that owns the comment.
 */
public function post()
{
 return $this->belongsTo('AppPost', 'foreign_key', 'other_key');
}

多对多

多对多的涉嫌比 hasOnehasMany关系要稍稍复杂一些。若是叁个用户全部三个角色,而剧中人物又有什么不可被别的的用户所分享。比如,两个用户能够有所管理员的剧中人物。若是定义这种关联,大家供给定义多少个数据库表:usersroles,和 role_userrole_user 表的命名是以相关联的多个模型数据表来依据字母顺序命名,何况表中包含了 user_idrole_id列。

多对多关系必要编写制定二个办法调用基础 EloquentbelongsToMany措施。比方,让大家在 User模型中定义四个 roles方法:

<?php

namespace App;

use IlluminateDatabaseEloquentModel;

class User extends Model
{
 /**
  * The roles that belong to the user.
  */
 public function roles()
 {
  return $this->belongsToMany('AppRole');
 }
}

即使涉及被定义,你能够透过 roles动态属性来拜谒用户的剧中人物:

$user = AppUser::find(1);

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

理当如此,就如其余类型的涉嫌,你能够调用 roles艺术而且链式调用查询条件:

$roles = AppUser::find(1)->roles()->orderBy('name')->get();

就好像先前所涉嫌的,Eloquent 会师併三个事关模型并依据字母逐个实行命名。当然你也得以随意的重写这一个约定,你能够传递第1个参数到 belongsToMany方法:

return $this->belongsToMany('AppRole', 'role_user');

除开自定义合併数据表的名号之外,你也能够经过往 belongsToMany办法传传递额外参数来自定义数据表里的键的字段名称。第多个参数是你定义在关乎中模型外键的称号。第多少个参数则是您要合併的模型外键的称呼:

return $this->belongsToMany('AppRole', 'role_user', 'user_id', 'role_id');

概念相对关联

你只供给在相对应的关联模型里停扬弃何的点子来调用 belongsToMany方法就足以定义相对关联。继续大家地点的用户剧中人物示例,让大家在 Role模型中定义四个 users方法:

<?php

namespace App;

use IlluminateDatabaseEloquentModel;

class Role extends Model
{
 /**
  * The users that belongs to the role.
  */
 public function users()
 {
  return $this->belongsToMany('AppUser');
 }
}

仿佛您所见到的,那一个涉及的定义与用户的涉及定义完全同样。因为我们再一次的应用了 belongsToMany方法,当定义相对于多对多的关联时,全数常用的自定义数据表和键的选项都以可用的。

查找中间表字段

正如你已经领悟到的。定义多对多的关联要求引进六当中间表。Eloquent 提供了两种非常有帮忙的章程来与那些表张开互动。例如,让大家假若大家的 User目的关系到了累累 Role目的。在做客这个关乎对象时,大家可以透过在模型上使用 pivot属性来访谈中间表:

$user = AppUser::find(1);

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

在意大家抽出的每种 Role目的,都会被电动的分配 pivot属性。那些脾气包罗了一个意味中间表的模子,並且能够像任何 Eloquent 模型同样被使用。

暗中同意的,唯有模型的键会被 pivot目的提供,假诺您的中间表包罗了额外的属性,你必须在概念关联时钦定它们:

return $this->belongsToMany('AppRole')->withPivot('column1', 'column2');

借使您想要中间表自动珍惜 created_atupdated_at岁月戳,你能够在概念关联时接纳 withTimestamps方法:

return $this->belongsToMany('AppRole')->withTimestamps();

本文由澳门正规赌博十大网站发布于澳门游戏网站,转载请注明出处:关联模型,laravel学习教程之关联模型