模型关联
简介
数据库表通常相互关联。例如,一篇博客文章可能有许多评论,或者一个订单对应一个下单用户。Orm 让这些关联的管理和使用变得简单,并支持多种常用的关联类型:
定义关联
一对一
一对一是最基本的数据库关系。 例如,一个 User
模型可能与一个 Phone
模型相关联。为了定义这个关联关系,我们要在 User
模型中定义一个 Phone
:
type User struct {
orm.Model
Name string
Phone *Phone
}
type Phone struct {
orm.Model
UserID uint
Name string
}
Orm 基于父模型(User
)的名称来确定关联模型(Phone
)的外键名称。在本例中,会自动假定 Phone
模型有一个 UserID
的外键。如果你想重写这个约定,可以在 User
模型中为 Phone
字段添加 foreignKey
Tag(其他关联关系类同):
type User struct {
orm.Model
Name string
Phone *Phone `gorm:"foreignKey:UserName"`
}
type Phone struct {
orm.Model
UserName string
Name string
}
另外,Orm
假设外键的值是与父模型的主键(Primary Key)相同的。换句话说,Orm
将会通过 Phone
记录的 UserID
列中查找与用户表的 id
列相匹配的值。如果你希望使用自定义的主键值,可以在 User
模型中为 Phone
字段添加 references
Tag(其他关联关系类同):
type User struct {
orm.Model
Name string
Phone *Phone `gorm:"foreignKey:UserName;references:name"`
}
type Phone struct {
orm.Model
UserName string
Name string
}
定义反向关联
我们已经能从 User
模型访问到 Phone
模型了。接下来,让我们再在 Phone
模型上定义一个关联,它能让我们访问到拥有该电话的用户。我们可以在 Phone
模型中定义一个 User
字段:
type User struct {
orm.Model
Name string
}
type Phone struct {
orm.Model
UserID uint
Name string
User *User
}
一对多
当要定义一个模型是其他 (一个或者多个)模型的父模型这种关系时,可以使用一对多关联。例如,一篇博客可以有很多条评论。和一对一模型关联一样,一对多关联也是在 Orm 模型文件中定义一个字段:
type Post struct {
orm.Model
Name string
Comments []*Comment
}
type Comment struct {
orm.Model
PostID uint
Name string
}
注意,Orm 将会自动为 Comment
模型选择一个合适的外键。通常,这个外键是通过使用父模型的「驼峰命名」方式,然后再加上 ID
的方式来命名的。因此,在上面这个例子中,Orm 将会默认 Comment
模型的外键是 PostID
字段。
一对多 (反向) / 属于
目前我们可以访问一篇文章的所有评论,下面我们可以定义一个关联关系,从而让我们可以通过一条评论来获取到它所属的文章。这个关联关系是 One To Many
的反向,可以在子模型中通过定义父模型字段:
type Post struct {
orm.Model
Name string
Comments []*Comment
}
type Comment struct {
orm.Model
PostID uint
Name string
Post *Post
}
多对多关联
多对多关联比 hasOne
和 hasMany
关联稍微复杂些。举个例子,一个用户可以拥有多个角色,同时这些角色也可以分配给其他用户。例如,一个用户可是「作者」和「编辑」;当然,这些角色也可以分配给其他用户。所以,一个用户可以拥有多个角色,一个角色可以分配给多个用户。
表结构
要定义这种关联,需要三个数据库表: users
, roles
和 role_user
。role_user
表的命名可以自定义。该表包含了 user_id
和 role_id
字段,用作链接 users
和 roles
的中间表。
特别提醒,由于角色可以属于多个用户,因此我们不能简单地在 roles
表上放置 user_id
列。如果这样,这意味着角色只能属于一个用户。为了支持将角色分配给多个用户,需要使用 role_user
表。我们可以这样定义表结构:
users
id - integer
name - string
roles
id - integer
name - string
role_user
user_id - integer
role_id - integer
模型结构
我们可以在 User
模型上定义一个 Roles
字段:
type User struct {
orm.Model
Name string
Roles []*Role `gorm:"many2many:role_user"`
}
type Role struct {
orm.Model
Name string
}
定义反向关联
要定义多对多的反向关联,只需要在 Role
模型中定义 Users
字段并附加 Tag:
type User struct {
orm.Model
Name string
Roles []*Role `gorm:"many2many:role_user"`
}
type Role struct {
orm.Model
Name string
Users []*User `gorm:"many2many:role_user"`
}
自定义中间表
通常,中间表外键是通过使用父模型的「蛇形」方式,然后再加上 _id
,您可以使用 joinForeignKey
与 joinReferences
对它进行重写:
type User struct {
orm.Model
Name string
Roles []*Role `gorm:"many2many:role_user;joinForeignKey:UserName;joinReferences:RoleName"`
}
type Role struct {
orm.Model
Name string
}
对应表结构:
users
id - integer
name - string
roles
id - integer
name - string
role_user
user_name - integer
role_name - integer
多态
多态关联允许目标模型借助单个关联从属于多个模型。例如,你正在构建一个允许用户共享博客文章和视频的应用程序,其中 Comment
模型可能同时从属于 Post
和 Video
模型。目前仅有 One To One
与 One To Many
支持多态。
表结构
多态关联与简单的关联类似,不过,目标模型能够在一个关联上从属于多个模型。例如,博客 Post
和 Video
可能共享一个关联到 Image
模型的关系,同时共享多个关联到 Comment
模型。让我们先看看表结构:
posts
id - integer
name - string
videos
id - integer
name - string
images
id - integer
url - string
imageable_id - integer
imageable_type - string
comments
id - integer
body - text
commentable_id - integer
commentable_type - string
要特别留意 images
表的 imageable_id
和 imageable_type
列。imageable_id
列包含文章或用户的 ID 值,而 imageable_type
列包含的则是父模型的类名。Orm 在访问 imageable
时使用 imageable_type
列来判断父模型的「类型」。comments
表类同。
模型结构
接下来,再看看建立关联的模型定义:
type Post struct {
orm.Model
Name string
Image *Image `gorm:"polymorphic:Imageable"`
Comments []*Comment `gorm:"polymorphic:Commentable"`
}
type Video struct {
orm.Model
Name string
Image *Image `gorm:"polymorphic:Imageable"`
Comments []*Comment `gorm:"polymorphic:Commentable"`
}
type Image struct {
orm.Model
Name string
ImageableID uint
ImageableType string
}
type Comment struct {
orm.Model
Name string
CommentableID uint
CommentableType string
}
您可以使用标签 polymorphicValue
来更改多态类型的值,例如:
type Post struct {
orm.Model
Name string
Image *Image `gorm:"polymorphic:Imageable;polymorphicValue:master"`
}
关联操作
假设有一个博客系统,它的 User
模型有许多关联的 Post
模型:
type User struct {
orm.Model
Name string
Posts []*Post
}
type Post struct {
orm.Model
UserID uint
Name string
}
创建/更新关联
可以使用 Select
, Omit
方法,对关联的创建和更新进行更细颗粒度控制。这两个方法不可同时使用,且对关联的控制功能只适用于 Create
, Update
, Save
:
user := models.User{Name: "user", Post: &models.Post{Name: "post"}}
// 创建 User 的同时创建所有子关联
facades.Orm().Query().Select(orm.Associations).Create(&user)
// 创建 User 的同时只创建 Post 子关联。注意:如果不使用 `orm.Associations`,而是单独自定义特定子关联,则此时也应将所有父模型中的字段列出。
facades.Orm().Query().Select("Name", "Post").Create(&user)
// 创建 User 时,忽略 Post 关联,但创建其他所有子关联
facades.Orm().Query().Omit("Post").Create(&user)
// 创建 User 时,忽略 Name 字段,但创建所有子关联
facades.Orm().Query().Omit("Name").Create(&user)
// 创建 User 时,忽略 Name 字段与所有子关联
facades.Orm().Query().Omit("Name", orm.Associations).Create(&user)
查找关联
// 查找所有匹配的关联记录
var posts []models.Post
facades.Orm().Query().Model(&user).Association("Posts").Find(&posts)
// 查找带条件的关联
facades.Orm().Query().Model(&user).Where("name = ?", "goravel").Order("id desc").Association("Posts").Find(&posts)
添加关联
为 manyToMany
, hasMany
添加新的关联;为 hasOne
, belongsTo
替换当前的关联:
facades.Orm().Query().Model(&user).Association("Posts").Append([]*models.Post{Post1, Post2})
facades.Orm().Query().Model(&user).Association("Posts").Append(&models.Post{Name: "goravel"})
替换关联
用一个新的关联替换当前的关联:
facades.Orm().Query().Model(&user).Association("Posts").Replace([]*models.Post{Post1, Post2})
facades.Orm().Query().Model(&user).Association("Posts").Replace(models.Post{Name: "goravel"}, Post2)
删除关联
如果关联存在,则删除父模型与子模型之间的关系,注意,只会删除引用,不会从数据库中删除这些对象,外键需要允许为 NULL:
facades.Orm().Query().Model(&user).Association("Posts").Delete([]*models.Post{Post1, Post2})
facades.Orm().Query().Model(&user).Association("Posts").Delete(Post1, Post2)
清空关联
删除父模型与子模型之间的所有引用,但不会删除这些关联:
facades.Orm().Query().Model(&user).Association("Posts").Clear()
关联计数
返回当前关联的数量:
facades.Orm().Query().Model(&user).Association("Posts").Count()
// 条件计数
facades.Orm().Query().Model(&user).Where("name = ?", "goravel").Association("Posts").Count()
批量处理数据
// 查询所有用户的所有文章
facades.Orm().Query().Model(&users).Association("Posts").Find(&posts)
// 从所有 Post 中删除 user A
facades.Orm().Query().Model(&users).Association("Posts").Delete(&userA)
// 获取去重的用户所属 Post 数量
facades.Orm().Query().Model(&users).Association("Posts").Count()
// 对于批量数据的 `Append`、`Replace`,参数的长度必须与数据的长度相同,否则会返回 error
var users = []models.User{user1, user2, user3}
// 有三个 user,Append userA 到 user1 的 team,Append userB 到 user2 的 team,Append userA、userB 和 userC 到 user3 的 team
facades.Orm().Query().Model(&users).Association("Team").Append(&userA, &userB, &[]models.User{userA, userB, userC})
// 重置 user1 team 为 userA,重置 user2 的 team 为 userB,重置 user3 的 team 为 userA、 userB 和 userC
facades.Orm().Query().Model(&users).Association("Team").Replace(&userA, &userB, &[]models.User{userA, userB, userC})
预加载
预加载为多个模型的查询提供方便,同时减轻了 N + 1
查询问题。 为了说明 N + 1
查询问题,请参考属于 Author
模型的 Book
模型:
type Author struct {
orm.Model
Name string
}
type Book struct {
orm.Model
AuthorID uint
Name string
Author *Author
}
我们检索所有书籍及其作者:
var books models.Book
facades.Orm().Query().Find(&books)
for _, book := range books {
var author models.Author
facades.Orm().Query().Find(&author, book.AuthorID)
}
该循环将执行一个查询以检索数据库表中的所有书籍,然后对每本书执行另一个查询以检索该书的作者。 因此,如果我们有 25 本书,上面的代码将运行 26 个查询:一个查询原本的书籍信息,另外 25 个查询来检索每本书的作者。
值得庆幸的是,我们可以使用预加载将这个操作减少到两个查询。 在构建查询时,可以使用 with 方法指定应该预加载哪些关系:
var books models.Book
facades.Orm().Query().With("Author").Find(&books)
for _, book := range books {
fmt.Println(book.Author)
}
对于此操作,将只执行两个查询 - 一个查询检索所有书籍,一个查询检索所有书籍的所有作者:
select * from `books`;
select * from `authors` where `id` in (1, 2, 3, 4, 5, ...);
预加载多个关联
有时,你可能需要在单一操作中预加载几个不同的关联。要达成此目的,只需要多次调用 With
方法:
var book models.Book
facades.Orm().Query().With("Author").With("Publisher").Find(&book)
嵌套预加载
可以使用 「点」 语法预加载嵌套关联。比如在一个 Orm 语句中预加载所有书籍作者及其联系方式:
var book models.Book
facades.Orm().Query().With("Author").With("Author.Contacts").Find(&book)
为预加载添加约束
有时,你可能希望预加载一个关联,同时为预加载查询添加额外查询条件。您可以通过下面方法来实现这一点:
import "github.com/goravel/framework/contracts/database/orm"
var book models.Book
facades.Orm().Query().With("Author", "name = ?", "author").Find(&book)
facades.Orm().Query().With("Author", func(query orm.Query) orm.Query {
return query.Where("name = ?", "author")
}).Find(&book)
在这个例子中,Orm 只会预加载作者的 name
列等于 author
的书籍。
延迟预加载
有时你可能需要在已检索到父模型后立即加载关系。例如,你需要动态决定是否加载相关模型,这可能很有用:
var books models.Book
facades.Orm().Query().Find(&books)
for _, book := range books {
if someCondition {
err := facades.Orm().Query().Load(&book, "Author")
}
}
如果要在延迟预加载的查询语句中进行条件约束,可以使用如下写法:
import "github.com/goravel/framework/contracts/database/orm"
var book models.Book
facades.Orm().Query().Load(&book, "Author", "name = ?", "author").Find(&book)
facades.Orm().Query().Load(&book, "Author", func(query orm.Query) orm.Query {
return query.Where("name = ?", "author")
}).Find(&book)
如果希望仅加载未被加载的关联关系时,你可以使用 LoadMissing
方法:
facades.Orm().Query().LoadMissing(&book, "Author")