[TOC] # 准备 ~~~ type User struct { Id int Name string Profile *Profile `orm:"rel(one)"` // OneToOne relation 有个profile_id Post []*Post `orm:"reverse(many)"` // 设置一对多的反向关系 } type Profile struct { Id int Age int16 User *User `orm:"reverse(one)"` // 设置一对一反向关系(可选) } type Post struct { Id int Title string User *User `orm:"rel(fk)"` //设置一对多关系 有个user_id Tags []*Tag `orm:"rel(m2m)"` } type Tag struct { Id int Name string Posts []*Post `orm:"reverse(many)"` } ~~~ # 一对多 User 和 Profile 是 OneToOne 的关系 已经取得了 User 对象,查询 Profile: ~~~ user := &User{Id: 1} o.Read(user) if user.Profile != nil { o.Read(user.Profile) } ~~~ 直接关联查询: ~~~ user := &User{} o.QueryTable("user").Filter("Id", 1).RelatedSel().One(user) // 自动查询到 Profile fmt.Println(user.Profile) // 因为在 Profile 里定义了反向关系的 User,所以 Profile 里的 User 也是自动赋值过的,可以直接取用。 fmt.Println(user.Profile.User) // [SELECT T0.`id`, T0.`name`, T0.`profile_id`, T1.`id`, T1.`age` FROM `user` T0 INNER JOIN `profile` T1 ON T1.`id` = T0.`profile_id` WHERE T0.`id` = ? LIMIT 1000] - `1` ~~~ 通过 User 反向查询 Profile: ~~~ var profile Profile err := o.QueryTable("profile").Filter("User__Id", 1).One(&profile) if err == nil { fmt.Println(profile) } ~~~ # 多对一 Post 和 User 是 ManyToOne 关系,也就是 ForeignKey 为 User ~~~ type Post struct { Id int Title string User *User `orm:"rel(fk)"` Tags []*Tag `orm:"rel(m2m)"` } ~~~ ~~~ var posts []*Post num, err := o.QueryTable("post").Filter("User", 1).RelatedSel().All(&posts) if err == nil { fmt.Printf("%d posts read\n", num) for _, post := range posts { fmt.Printf("Id: %d, UserName: %d, Title: %s\n", post.Id, post.User.UserName, post.Title) } } // [SELECT T0.`id`, T0.`title`, T0.`user_id`, T1.`id`, T1.`name`, T1.`profile_id`, T2.`id`, T2.`age` FROM `post` T0 INNER JOIN `user` T1 ON T1.`id` = T0.`user_id` INNER JOIN `profile` T2 ON T2.`id` = T1.`profile_id` WHERE T0.`user_id` = ? LIMIT 1000] - `1` ~~~ 根据 Post.Title 查询对应的 User: RegisterModel 时,ORM 也会自动建立 User 中 Post 的反向关系,所以可以直接进行查询 ~~~ var user User err := o.QueryTable("user").Filter("Post__Title", "The Title").Limit(1).One(&user) if err == nil { fmt.Printf(user) } ~~~ # 多对多 Post 和 Tag 是 ManyToMany 关系 设置 rel(m2m) 以后,ORM 会自动创建中间表 ~~~ type Post struct { Id int Title string User *User `orm:"rel(fk)"` Tags []*Tag `orm:"rel(m2m)"` } ~~~ ~~~ type Tag struct { Id int Name string Posts []*Post `orm:"reverse(many)"` } ~~~ 一条 Post 纪录可能对应不同的 Tag 纪录,一条 Tag 纪录可能对应不同的 Post 纪录,所以 Post 和 Tag 属于多对多关系,通过 tag name 查询哪些 post 使用了这个 tag ~~~ var posts []*Post num, err := dORM.QueryTable("post").Filter("Tags__Tag__Name", "golang").All(&posts) ~~~ 通过 post title 查询这个 post 有哪些 tag ~~~ var tags []*Tag num, err := dORM.QueryTable("tag").Filter("Posts__Post__Title", "Introduce Beego ORM").All(&tags) ~~~ # 载入关系字段 LoadRelated 用于载入模型的关系字段,包括所有的 rel/reverse - one/many 关系 ManyToMany 关系字段载入 ~~~ // 载入相应的 Tags post := Post{Id: 1} err := o.Read(&post) num, err := o.LoadRelated(&post, "Tags") ~~~ ~~~ // 载入相应的 Posts tag := Tag{Id: 1} err := o.Read(&tag) num, err := o.LoadRelated(&tag, "Posts") ~~~ User 是 Post 的 ForeignKey,对应的 ReverseMany 关系字段载入 ~~~ type User struct { Id int Name string Posts []*Post `orm:"reverse(many)"` } user := User{Id: 1} err := dORM.Read(&user) num, err := dORM.LoadRelated(&user, "Posts") for _, post := range user.Posts { //... } ~~~ # 多对多关系操作 * type QueryM2Mer interface { * [Add(…interface{}) (int64, error)](https://beego.me/docs/mvc/model/query.md#querym2mer-add) * [Remove(…interface{}) (int64, error)](https://beego.me/docs/mvc/model/query.md#querym2mer-remove) * [Exist(interface{}) bool](https://beego.me/docs/mvc/model/query.md#querym2mer-exist) * [Clear() (int64, error)](https://beego.me/docs/mvc/model/query.md#querym2mer-clear) * [Count() (int64, error)](https://beego.me/docs/mvc/model/query.md#querym2mer-count) * } 创建一个 QueryM2Mer 对象 ~~~ o := orm.NewOrm() post := Post{Id: 1} m2m := o.QueryM2M(&post, "Tags") // 第一个参数的对象,主键必须有值 // 第二个参数为对象需要操作的 M2M 字段 // QueryM2Mer 的 api 将作用于 Id 为 1 的 Post ~~~ ## Add ~~~ tag := &Tag{Name: "golang"} o.Insert(tag) num, err := m2m.Add(tag) if err == nil { fmt.Println("Added nums: ", num) } ~~~ Add 支持多种类型 Tag \*Tag \[\]\*Tag \[\]Tag \[\]interface{} ~~~ var tags []*Tag ... // 读取 tags 以后 ... num, err := m2m.Add(tags) if err == nil { fmt.Println("Added nums: ", num) } // 也可以多个作为参数传入 // m2m.Add(tag1, tag2, tag3) ~~~ ## Remove 从M2M关系中删除 tag Remove 支持多种类型 Tag \*Tag \[\]\*Tag \[\]Tag \[\]interface{} ~~~ var tags []*Tag ... // 读取 tags 以后 ... num, err := m2m.Remove(tags) if err == nil { fmt.Println("Removed nums: ", num) } // 也可以多个作为参数传入 // m2m.Remove(tag1, tag2, tag3) ~~~ ## Exist 判断 Tag 是否存在于 M2M 关系中 ~~~ if m2m.Exist(&Tag{Id: 2}) { fmt.Println("Tag Exist") } ~~~ ## Clear 清除所有 M2M 关系 ~~~ nums, err := m2m.Clear() if err == nil { fmt.Println("Removed Tag Nums: ", nums) } ~~~ ## Count 计算 Tag 的数量 ~~~ nums, err := m2m.Count() if err == nil { fmt.Println("Total Nums: ", nums) } ~~~