高级查询

ORM 以 QuerySeter 来组织查询，每个返回 QuerySeter 的方法都会获得一个新的 QuerySeter 对象。

基本使用方法:

  1. o := orm.NewOrm()
  3. // 获取 QuerySeter 对象，user 为表名
  4. qs := o.QueryTable("user")
  6. // 也可以直接使用 Model 结构体作为表名
  7. qs = o.QueryTable(&User)
  9. // 也可以直接使用对象作为表名
  10. user := new(User)
  11. qs = o.QueryTable(user) // 返回 QuerySeter

expr

QuerySeter 中用于描述字段和 sql 操作符，使用简单的 expr 查询方法

字段组合的前后顺序依照表的关系，比如 User 表拥有 Profile 的外键，那么对 User 表查询对应的 Profile.Age 为条件，则使用 Profile__Age 注意，字段的分隔符号使用双下划线 __，除了描述字段， expr 的尾部可以增加操作符以执行对应的 sql 操作。比如 Profile__Age__gt 代表 Profile.Age > 18 的条件查询。

注释后面将描述对应的 sql 语句，仅仅是描述 expr 的类似结果，并不代表实际生成的语句。

  1. qs.Filter("id", 1) // WHERE id = 1
  2. qs.Filter("profile__age", 18) // WHERE profile.age = 18
  3. qs.Filter("Profile__Age", 18) // 使用字段名和 Field 名都是允许的
  4. qs.Filter("profile__age__gt", 18) // WHERE profile.age > 18
  5. qs.Filter("profile__age__gte", 18) // WHERE profile.age >= 18
  6. qs.Filter("profile__age__in", 18, 20) // WHERE profile.age IN (18, 20)
  8. qs.Filter("profile__age__in", 18, 20).Exclude("profile__lt", 1000)
  9. // WHERE profile.age IN (18, 20) AND NOT profile_id < 1000

Operators

当前支持的操作符号：

后面以 i 开头的表示：大小写不敏感

exact

Filter / Exclude / Condition expr 的默认值

  1. qs.Filter("name", "slene") // WHERE name = 'slene'
  2. qs.Filter("name__exact", "slene") // WHERE name = 'slene'
  3. // 使用 = 匹配，大小写是否敏感取决于数据表使用的 collation
  4. qs.Filter("profile_id", nil) // WHERE profile_id IS NULL

iexact

  1. qs.Filter("name__iexact", "slene")
  2. // WHERE name LIKE 'slene'
  3. // 大小写不敏感，匹配任意 'Slene' 'sLENE'

contains

  1. qs.Filter("name__contains", "slene")
  2. // WHERE name LIKE BINARY '%slene%'
  3. // 大小写敏感, 匹配包含 slene 的字符

icontains

  1. qs.Filter("name__icontains", "slene")
  2. // WHERE name LIKE '%slene%'
  3. // 大小写不敏感, 匹配任意 'im Slene', 'im sLENE'

in

  1. qs.Filter("age__in", 17, 18, 19, 20)
  2. // WHERE age IN (17, 18, 19, 20)
  5. ids:=[]int{17,18,19,20}
  6. qs.Filter("age__in", ids)
  7. // WHERE age IN (17, 18, 19, 20)
  9. // 同上效果

gt / gte

  1. qs.Filter("profile__age__gt", 17)
  2. // WHERE profile.age > 17
  4. qs.Filter("profile__age__gte", 18)
  5. // WHERE profile.age >= 18

lt / lte

  1. qs.Filter("profile__age__lt", 17)
  2. // WHERE profile.age < 17
  4. qs.Filter("profile__age__lte", 18)
  5. // WHERE profile.age <= 18

startswith

  1. qs.Filter("name__startswith", "slene")
  2. // WHERE name LIKE BINARY 'slene%'
  3. // 大小写敏感, 匹配以 'slene' 起始的字符串

istartswith

  1. qs.Filter("name__istartswith", "slene")
  2. // WHERE name LIKE 'slene%'
  3. // 大小写不敏感, 匹配任意以 'slene', 'Slene' 起始的字符串

endswith

  1. qs.Filter("name__endswith", "slene")
  2. // WHERE name LIKE BINARY '%slene'
  3. // 大小写敏感, 匹配以 'slene' 结束的字符串

iendswith

  1. qs.Filter("name__iendswithi", "slene")
  2. // WHERE name LIKE '%slene'
  3. // 大小写不敏感, 匹配任意以 'slene', 'Slene' 结束的字符串

isnull

  1. qs.Filter("profile__isnull", true)
  2. qs.Filter("profile_id__isnull", true)
  3. // WHERE profile_id IS NULL
  5. qs.Filter("profile__isnull", false)
  6. // WHERE profile_id IS NOT NULL

高级查询接口使用

QuerySeter 是高级查询使用的接口，我们来熟悉下他的接口方法

  1. type QuerySeter interface {
  2. // add condition expression to QuerySeter.
  3. // for example:
  4. //    filter by UserName == 'slene'
  5. //    qs.Filter("UserName", "slene")
  6. //    sql : left outer join profile on t0.id1==t1.id2 where t1.age == 28
  7. //    Filter("profile__Age", 28)
  8. //      // time compare
  9. //    qs.Filter("created", time.Now())
  10. Filter(string, ...interface{}) QuerySeter
  11. // add raw sql to querySeter.
  12. // for example:
  13. // qs.FilterRaw("user_id IN (SELECT id FROM profile WHERE age>=18)")
  14. // //sql-> WHERE user_id IN (SELECT id FROM profile WHERE age>=18)
  15. FilterRaw(string, string) QuerySeter
  16. // add NOT condition to querySeter.
  17. // have the same usage as Filter
  18. Exclude(string, ...interface{}) QuerySeter
  19. // set condition to QuerySeter.
  20. // sql's where condition
  21. //    cond := orm.NewCondition()
  22. //    cond1 := cond.And("profile__isnull", false).AndNot("status__in", 1).Or("profile__age__gt", 2000)
  23. //    //sql-> WHERE T0.`profile_id` IS NOT NULL AND NOT T0.`Status` IN (?) OR T1.`age` >  2000
  24. //    num, err := qs.SetCond(cond1).Count()
  25. SetCond(*Condition) QuerySeter
  26. // get condition from QuerySeter.
  27. // sql's where condition
  28. //  cond := orm.NewCondition()
  29. //  cond = cond.And("profile__isnull", false).AndNot("status__in", 1)
  30. //  qs = qs.SetCond(cond)
  31. //  cond = qs.GetCond()
  32. //  cond := cond.Or("profile__age__gt", 2000)
  33. //  //sql-> WHERE T0.`profile_id` IS NOT NULL AND NOT T0.`Status` IN (?) OR T1.`age` >  2000
  34. //  num, err := qs.SetCond(cond).Count()
  35. GetCond() *Condition
  36. // add LIMIT value.
  37. // args[0] means offset, e.g. LIMIT num,offset.
  38. // if Limit <= 0 then Limit will be set to default limit ,eg 1000
  39. // if QuerySeter doesn't call Limit, the sql's Limit will be set to default limit, eg 1000
  40. //  for example:
  41. //    qs.Limit(10, 2)
  42. //    // sql-> limit 10 offset 2
  43. Limit(limit interface{}, args ...interface{}) QuerySeter
  44. // add OFFSET value
  45. // same as Limit function's args[0]
  46. Offset(offset interface{}) QuerySeter
  47. // add GROUP BY expression
  48. // for example:
  49. //    qs.GroupBy("id")
  50. GroupBy(exprs ...string) QuerySeter
  51. // add ORDER expression.
  52. // "column" means ASC, "-column" means DESC.
  53. // for example:
  54. //    qs.OrderBy("-status")
  55. OrderBy(exprs ...string) QuerySeter
  56. // add FORCE INDEX expression.
  57. // for example:
  58. //    qs.ForceIndex(`idx_name1`,`idx_name2`)
  59. // ForceIndex, UseIndex , IgnoreIndex are mutually exclusive
  60. ForceIndex(indexes ...string) QuerySeter
  61. // add USE INDEX expression.
  62. // for example:
  63. //    qs.UseIndex(`idx_name1`,`idx_name2`)
  64. // ForceIndex, UseIndex , IgnoreIndex are mutually exclusive
  65. UseIndex(indexes ...string) QuerySeter
  66. // add IGNORE INDEX expression.
  67. // for example:
  68. //    qs.IgnoreIndex(`idx_name1`,`idx_name2`)
  69. // ForceIndex, UseIndex , IgnoreIndex are mutually exclusive
  70. IgnoreIndex(indexes ...string) QuerySeter
  71. // set relation model to query together.
  72. // it will query relation models and assign to parent model.
  73. // for example:
  74. //    // will load all related fields use left join .
  75. //     qs.RelatedSel().One(&user)
  76. //    // will  load related field only profile
  77. //    qs.RelatedSel("profile").One(&user)
  78. //    user.Profile.Age = 32
  79. RelatedSel(params ...interface{}) QuerySeter
  80. // Set Distinct
  81. // for example:
  82. //  o.QueryTable("policy").Filter("Groups__Group__Users__User", user).
  83. //    Distinct().
  84. //    All(&permissions)
  85. Distinct() QuerySeter
  86. // set FOR UPDATE to query.
  87. // for example:
  88. //  o.QueryTable("user").Filter("uid", uid).ForUpdate().All(&users)
  89. ForUpdate() QuerySeter
  90. // return QuerySeter execution result number
  91. // for example:
  92. //    num, err = qs.Filter("profile__age__gt", 28).Count()
  93. Count() (int64, error)
  94. // check result empty or not after QuerySeter executed
  95. // the same as QuerySeter.Count > 0
  96. Exist() bool
  97. // execute update with parameters
  98. // for example:
  99. //    num, err = qs.Filter("user_name", "slene").Update(Params{
  100. //        "Nums": ColValue(Col_Minus, 50),
  101. //    }) // user slene's Nums will minus 50
  102. //    num, err = qs.Filter("UserName", "slene").Update(Params{
  103. //        "user_name": "slene2"
  104. //    }) // user slene's  name will change to slene2
  105. Update(values Params) (int64, error)
  106. // delete from table
  107. // for example:
  108. //    num ,err = qs.Filter("user_name__in", "testing1", "testing2").Delete()
  109. //     //delete two user  who's name is testing1 or testing2
  110. Delete() (int64, error)
  111. // return a insert queryer.
  112. // it can be used in times.
  113. // example:
  114. //     i,err := sq.PrepareInsert()
  115. //     num, err = i.Insert(&user1) // user table will add one record user1 at once
  116. //    num, err = i.Insert(&user2) // user table will add one record user2 at once
  117. //    err = i.Close() //don't forget call Close
  118. PrepareInsert() (Inserter, error)
  119. // query all data and map to containers.
  120. // cols means the columns when querying.
  121. // for example:
  122. //    var users []*User
  123. //    qs.All(&users) // users[0],users[1],users[2] ...
  124. All(container interface{}, cols ...string) (int64, error)
  125. // query one row data and map to containers.
  126. // cols means the columns when querying.
  127. // for example:
  128. //    var user User
  129. //    qs.One(&user) //user.UserName == "slene"
  130. One(container interface{}, cols ...string) error
  131. // query all data and map to []map[string]interface.
  132. // expres means condition expression.
  133. // it converts data to []map[column]value.
  134. // for example:
  135. //    var maps []Params
  136. //    qs.Values(&maps) //maps[0]["UserName"]=="slene"
  137. Values(results *[]Params, exprs ...string) (int64, error)
  138. // query all data and map to [][]interface
  139. // it converts data to [][column_index]value
  140. // for example:
  141. //    var list []ParamsList
  142. //    qs.ValuesList(&list) // list[0][1] == "slene"
  143. ValuesList(results *[]ParamsList, exprs ...string) (int64, error)
  144. // query all data and map to []interface.
  145. // it's designed for one column record set, auto change to []value, not [][column]value.
  146. // for example:
  147. //    var list ParamsList
  148. //    qs.ValuesFlat(&list, "UserName") // list[0] == "slene"
  149. ValuesFlat(result *ParamsList, expr string) (int64, error)
  150. // query all rows into map[string]interface with specify key and value column name.
  151. // keyCol = "name", valueCol = "value"
  152. // table data
  153. // name  | value
  154. // total | 100
  155. // found | 200
  156. // to map[string]interface{}{
  157. //     "total": 100,
  158. //     "found": 200,
  159. // }
  160. RowsToMap(result *Params, keyCol, valueCol string) (int64, error)
  161. // query all rows into struct with specify key and value column name.
  162. // keyCol = "name", valueCol = "value"
  163. // table data
  164. // name  | value
  165. // total | 100
  166. // found | 200
  167. // to struct {
  168. //     Total int
  169. //     Found int
  170. // }
  171. RowsToStruct(ptrStruct interface{}, keyCol, valueCol string) (int64, error)
  172. }

  • 每个返回 QuerySeter 的 api 调用时都会新建一个 QuerySeter，不影响之前创建的。

  • 高级查询使用 Filter 和 Exclude 来做常用的条件查询。囊括两种清晰的过滤规则：包含， 排除

Filter

用来过滤查询结果，起到 包含条件 的作用

多个 Filter 之间使用 AND 连接

  1. qs.Filter("profile__isnull", true).Filter("name", "slene")
  2. // WHERE profile_id IS NULL AND name = 'slene'

Exclude

用来过滤查询结果，起到 排除条件 的作用

使用 NOT 排除条件

多个 Exclude 之间使用 AND 连接

  1. qs.Exclude("profile__isnull", true).Filter("name", "slene")
  2. // WHERE NOT profile_id IS NULL AND name = 'slene'

SetCond

自定义条件表达式

  1. cond := orm.NewCondition()
  2. cond1 := cond.And("profile__isnull", false).AndNot("status__in", 1).Or("profile__age__gt", 2000)
  4. qs := orm.QueryTable("user")
  5. qs = qs.SetCond(cond1)
  6. // WHERE ... AND ... AND NOT ... OR ...
  8. cond2 := cond.AndCond(cond1).OrCond(cond.And("name", "slene"))
  9. qs = qs.SetCond(cond2).Count()
  10. // WHERE (... AND ... AND NOT ... OR ...) OR ( ... )

Limit

限制最大返回数据行数，第二个参数可以设置 Offset

  1. var DefaultRowsLimit = 1000 // ORM 默认的 limit 值为 1000
  3. // 默认情况下 select 查询的最大行数为 1000
  4. // LIMIT 1000
  6. qs.Limit(10)
  7. // LIMIT 10
  9. qs.Limit(10, 20)
  10. // LIMIT 10 OFFSET 20 注意跟 SQL 反过来的
  12. qs.Limit(-1)
  13. // no limit
  15. qs.Limit(-1, 100)
  16. // LIMIT 18446744073709551615 OFFSET 100
  17. // 18446744073709551615 是 1<<64 - 1 用来指定无 limit 限制 但有 offset 偏移的情况

Offset

设置 偏移行数

  1. qs.Offset(20)
  2. // LIMIT 1000 OFFSET 20

GroupBy

  1. qs.GroupBy("id", "age")
  2. // GROUP BY id,age

OrderBy

参数使用 expr

在 expr 前使用减号 - 表示 DESC 的排列

  1. qs.OrderBy("id", "-profile__age")
  2. // ORDER BY id ASC, profile.age DESC
  4. qs.OrderBy("-profile__age", "profile")
  5. // ORDER BY profile.age DESC, profile_id ASC

ForceIndex

强迫走索引。使用该选选项请确认数据库支持该特性。

  1. qs.ForceIndex(`idx_name1`,`idx_name2`)

UseIndex

使用索引。使用该特性的时候需要确认数据库是否支持该特性，以及该特性的具体含义。例如，部分数据库对于该选项是当成一种建议来执行的。

即，即便用户使用了UseIndex方法，但是数据库在具体执行的时候，也可能不会使用设定的索引。

  1. qs.UseIndex(`idx_name1`,`idx_name2`)

IgnoreIndex

忽略索引。请确认数据是否支持该选项。

  1. qs.IgnoreIndex(`idx_name1`,`idx_name2`)

Distinct

对应 sql 的 distinct 语句, 返回指定字段不重复的值.

  1. qs.Distinct()
  2. // SELECT DISTINCT

RelatedSel

关系查询，参数使用 expr

  1. var DefaultRelsDepth = 5 // 默认情况下直接调用 RelatedSel 将进行最大 5 层的关系查询
  3. qs := o.QueryTable("post")
  5. qs.RelatedSel()
  6. // INNER JOIN user ... LEFT OUTER JOIN profile ...
  8. qs.RelatedSel("user")
  9. // INNER JOIN user ...
  10. // 设置 expr 只对设置的字段进行关系查询
  12. // 对设置 null 属性的 Field 将使用 LEFT OUTER JOIN

Count

依据当前的查询条件，返回结果行数

  1. cnt, err := o.QueryTable("user").Count() // SELECT COUNT(*) FROM USER
  2. fmt.Printf("Count Num: %s, %s", cnt, err)

Exist

  1. exist := o.QueryTable("user").Filter("UserName", "Name").Exist()
  2. fmt.Printf("Is Exist: %s", exist)

Update

依据当前查询条件，进行批量更新操作

  1. num, err := o.QueryTable("user").Filter("name", "slene").Update(orm.Params{
  2.     "name": "astaxie",
  3. })
  4. fmt.Printf("Affected Num: %s, %s", num, err)
  5. // SET name = "astaixe" WHERE name = "slene"

原子操作增加字段值

  1. // 假设 user struct 里有一个 nums int 字段
  2. num, err := o.QueryTable("user").Update(orm.Params{
  3.     "nums": orm.ColValue(orm.ColAdd, 100),
  4. })
  5. // SET nums = nums + 100

orm.ColValue 支持以下操作

  1. ColAdd      // 加
  2. ColMinus    // 减
  3. ColMultiply // 乘
  4. ColExcept   // 除

Delete

依据当前查询条件，进行批量删除操作

  1. num, err := o.QueryTable("user").Filter("name", "slene").Delete()
  2. fmt.Printf("Affected Num: %s, %s", num, err)
  3. // DELETE FROM user WHERE name = "slene"

PrepareInsert

用于一次 prepare 多次 insert 插入，以提高批量插入的速度。

  1. var users []*User
  2. ...
  3. qs := o.QueryTable("user")
  4. i, _ := qs.PrepareInsert()
  5. for _, user := range users {
  6.     id, err := i.Insert(user)
  7.     if err == nil {
  8.         ...
  9.     }
  10. }
  11. // PREPARE INSERT INTO user (`name`, ...) VALUES (?, ...)
  12. // EXECUTE INSERT INTO user (`name`, ...) VALUES ("slene", ...)
  13. // EXECUTE ...
  14. // ...
  15. i.Close() // 别忘记关闭 statement

All

返回对应的结果集对象

All 的参数支持 []Type 和 []*Type 两种形式的 slice

  1. var users []*User
  2. num, err := o.QueryTable("user").Filter("name", "slene").All(&users)
  3. fmt.Printf("Returned Rows Num: %s, %s", num, err)

All / Values / ValuesList / ValuesFlat 受到 Limit 的限制，默认最大行数为 1000

可以指定返回的字段：

  1. type Post struct {
  2.     Id      int
  3.     Title   string
  4.     Content string
  5.     Status  int
  6. }
  8. // 只返回 Id 和 Title
  9. var posts []Post
  10. o.QueryTable("post").Filter("Status", 1).All(&posts, "Id", "Title")

对象的其他字段值将会是对应类型的默认值

One

尝试返回单条记录

  1. var user User
  2. err := o.QueryTable("user").Filter("name", "slene").One(&user)
  3. if err == orm.ErrMultiRows {
  4.     // 多条的时候报错
  5.     fmt.Printf("Returned Multi Rows Not One")
  6. }
  7. if err == orm.ErrNoRows {
  8.     // 没有找到记录
  9.     fmt.Printf("Not row found")
  10. }

可以指定返回的字段：

  1. // 只返回 Id 和 Title
  2. var post Post
  3. o.QueryTable("post").Filter("Content__istartswith", "prefix string").One(&post, "Id", "Title")

对象的其他字段值将会是对应类型的默认值

Values

返回结果集的 key => value 值

key 为Model里的Field name, value的值是interface{}类型,例如，如果你要将value赋值给struct中的某字段，需要根据结构体对应字段类型使用断言获取真实值。举例:Name : m["Name"].(string)

  1. var maps []orm.Params
  2. num, err := o.QueryTable("user").Values(&maps)
  3. if err == nil {
  4.     fmt.Printf("Result Nums: %d\n", num)
  5.     for _, m := range maps {
  6.         fmt.Println(m["Id"], m["Name"])
  7.     }
  8. }

返回指定的 Field 数据

TODO: 暂不支持级联查询 RelatedSel 直接返回 Values

但可以直接指定 expr 级联返回需要的数据

  1. var maps []orm.Params
  2. num, err := o.QueryTable("user").Values(&maps, "id", "name", "profile", "profile__age")
  3. if err == nil {
  4.     fmt.Printf("Result Nums: %d\n", num)
  5.     for _, m := range maps {
  6.         fmt.Println(m["Id"], m["Name"], m["Profile"], m["Profile__Age"])
  7.         // map 中的数据都是展开的，没有复杂的嵌套
  8.     }
  9. }

ValuesList

顾名思义，返回的结果集以slice存储

结果的排列与 Model 中定义的 Field 顺序一致

返回的每个元素值以 string 保存

  1. var lists []orm.ParamsList
  2. num, err := o.QueryTable("user").ValuesList(&lists)
  3. if err == nil {
  4.     fmt.Printf("Result Nums: %d\n", num)
  5.     for _, row := range lists {
  6.         fmt.Println(row)
  7.     }
  8. }

当然也可以指定 expr 返回指定的 Field

  1. var lists []orm.ParamsList
  2. num, err := o.QueryTable("user").ValuesList(&lists, "name", "profile__age")
  3. if err == nil {
  4.     fmt.Printf("Result Nums: %d\n", num)
  5.     for _, row := range lists {
  6.         fmt.Printf("Name: %s, Age: %s\m", row[0], row[1])
  7.     }
  8. }

ValuesFlat

只返回特定的 Field 值，将结果集展开到单个 slice 里

  1. var list orm.ParamsList
  2. num, err := o.QueryTable("user").ValuesFlat(&list, "name")
  3. if err == nil {
  4.     fmt.Printf("Result Nums: %d\n", num)
  5.     fmt.Printf("All User Names: %s", strings.Join(list, ", "))
  6. }

关系查询

以例子里的模型定义来看下怎么进行关系查询

User 和 Profile 是 OneToOne 的关系

已经取得了 User 对象，查询 Profile：

  1. user := &User{Id: 1}
  2. o.Read(user)
  3. if user.Profile != nil {
  4.     o.Read(user.Profile)
  5. }

直接关联查询：

  1. user := &User{}
  2. o.QueryTable("user").Filter("Id", 1).RelatedSel().One(user)
  3. // 自动查询到 Profile
  4. fmt.Println(user.Profile)
  5. // 因为在 Profile 里定义了反向关系的 User，所以 Profile 里的 User 也是自动赋值过的，可以直接取用。
  6. fmt.Println(user.Profile.User)
  8. // [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：

  1. var profile Profile
  2. err := o.QueryTable("profile").Filter("User__Id", 1).One(&profile)
  3. if err == nil {
  4.     fmt.Println(profile)
  5. }

Post 和 User 是 ManyToOne 关系，也就是 ForeignKey 为 User

  1. type Post struct {
  2.     Id    int
  3.     Title string
  4.     User  *User  `orm:"rel(fk)"`
  5.     Tags  []*Tag `orm:"rel(m2m)"`
  6. }
  1. var posts []*Post
  2. num, err := o.QueryTable("post").Filter("User", 1).RelatedSel().All(&posts)
  3. if err == nil {
  4.     fmt.Printf("%d posts read\n", num)
  5.     for _, post := range posts {
  6.         fmt.Printf("Id: %d, UserName: %d, Title: %s\n", post.Id, post.User.UserName, post.Title)
  7.     }
  8. }
  9. // [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 的反向关系，所以可以直接进行查询

  1. var user User
  2. err := o.QueryTable("user").Filter("Post__Title", "The Title").Limit(1).One(&user)
  3. if err == nil {
  4.     fmt.Printf(user)
  5. }

Post 和 Tag 是 ManyToMany 关系

设置 rel(m2m) 以后，ORM 会自动创建中间表

  1. type Post struct {
  2.     Id    int
  3.     Title string
  4.     User  *User  `orm:"rel(fk)"`
  5.     Tags  []*Tag `orm:"rel(m2m)"`
  6. }
  1. type Tag struct {
  2.     Id    int
  3.     Name  string
  4.     Posts []*Post `orm:"reverse(many)"`
  5. }

一条 Post 纪录可能对应不同的 Tag 纪录,一条 Tag 纪录可能对应不同的 Post 纪录，所以 Post 和 Tag 属于多对多关系,通过 tag name 查询哪些 post 使用了这个 tag

  1. var posts []*Post
  2. num, err := dORM.QueryTable("post").Filter("Tags__Tag__Name", "golang").All(&posts)

通过 post title 查询这个 post 有哪些 tag

  1. var tags []*Tag
  2. num, err := dORM.QueryTable("tag").Filter("Posts__Post__Title", "Introduce Beego ORM").All(&tags)

载入关系字段

LoadRelated 用于载入模型的关系字段，包括所有的 rel/reverse - one/many 关系

ManyToMany 关系字段载入

  1. // 载入相应的 Tags
  2. post := Post{Id: 1}
  3. err := o.Read(&post)
  4. num, err := o.LoadRelated(&post, "Tags")
  1. // 载入相应的 Posts
  2. tag := Tag{Id: 1}
  3. err := o.Read(&tag)
  4. num, err := o.LoadRelated(&tag, "Posts")

User 是 Post 的 ForeignKey，对应的 ReverseMany 关系字段载入

  1. type User struct {
  2.     Id    int
  3.     Name  string
  4.     Posts []*Post `orm:"reverse(many)"`
  5. }
  7. user := User{Id: 1}
  8. err := dORM.Read(&user)
  9. num, err := dORM.LoadRelated(&user, "Posts")
  10. for _, post := range user.Posts {
  11.     //...
  12. }

多对多关系操作

创建一个 QueryM2Mer 对象

  1. o := orm.NewOrm()
  2. post := Post{Id: 1}
  3. m2m := o.QueryM2M(&post, "Tags")
  4. // 第一个参数的对象，主键必须有值
  5. // 第二个参数为对象需要操作的 M2M 字段
  6. // QueryM2Mer 的 api 将作用于 Id 为 1 的 Post

QueryM2Mer Add

  1. tag := &Tag{Name: "golang"}
  2. o.Insert(tag)
  4. num, err := m2m.Add(tag)
  5. if err == nil {
  6.     fmt.Println("Added nums: ", num)
  7. }

Add 支持多种类型 Tag Tag []Tag []Tag []interface{}

  1. var tags []*Tag
  2. ...
  3. // 读取 tags 以后
  4. ...
  5. num, err := m2m.Add(tags)
  6. if err == nil {
  7.     fmt.Println("Added nums: ", num)
  8. }
  9. // 也可以多个作为参数传入
  10. // m2m.Add(tag1, tag2, tag3)

QueryM2Mer Remove

从M2M关系中删除 tag

Remove 支持多种类型 Tag Tag []Tag []Tag []interface{}

  1. var tags []*Tag
  2. ...
  3. // 读取 tags 以后
  4. ...
  5. num, err := m2m.Remove(tags)
  6. if err == nil {
  7.     fmt.Println("Removed nums: ", num)
  8. }
  9. // 也可以多个作为参数传入
  10. // m2m.Remove(tag1, tag2, tag3)

QueryM2Mer Exist

判断 Tag 是否存在于 M2M 关系中

  1. if m2m.Exist(&Tag{Id: 2}) {
  2.     fmt.Println("Tag Exist")
  3. }

QueryM2Mer Clear

清除所有 M2M 关系

  1. nums, err := m2m.Clear()
  2. if err == nil {
  3.     fmt.Println("Removed Tag Nums: ", nums)
  4. }

QueryM2Mer Count

计算 Tag 的数量

  1. nums, err := m2m.Count()
  2. if err == nil {
  3.     fmt.Println("Total Nums: ", nums)
  4. }