3.4 Beego高级查询
1.高级查询
ORM 以 QuerySeter 来组织查询，每个返回 QuerySeter 的方法都会获得一个新的 QuerySeter 对象。
基本使用方法:
o := orm.NewOrm()
// 获取 QuerySeter 对象，user 为表名
qs := o.QueryTable("user")
// 也可以直接使用对象作为表名
user := new(User)
qs = o.QueryTable(user)
1.1. expr
QuerySeter 中用于描述字段和 sql 操作符，使用简单的 expr 查询方法
字段组合的前后顺序依照表的关系，比如 User 表拥有 Profile 的外键，那么对 User 表查询对应的 Profile.Age 为条件，则使用 Profile__Age 注意，字段的分隔符号使用双下划线 __，除了描述字段， expr 的尾部可以增加操作符以执行对应的 sql 操作。比如 Profile__Age__gt 代表 Profile.Age > 18 的条件查询。
注释后面将描述对应的 sql 语句，仅仅是描述 expr 的类似结果，并不代表实际生成的语句。
qs.Filter("id", 1)
qs.Filter("profile__age", 18)
qs.Filter("Profile__Age", 18)
qs.Filter("profile__age", 18)
qs.Filter("profile__age__gt", 18)
qs.Filter("profile__age__gte", 18)
qs.Filter("profile__age__in", 18, 20)
qs.Filter("profile__age__in", 18, 20).Exclude("profile__lt", 1000)
1.2. Operators
当前支持的操作符号：
- exact / iexact 等于
- contains / icontains 包含
- gt / gte 大于 / 大于等于
- lt / lte 小于 / 小于等于
- startswith / istartswith 以... 起始
- endswith / iendswith 以... 结束
- in
- isnull
后面以 i 开头的表示：大小写不敏感
1.2.1. exact
Filter / Exclude / Condition expr 的默认值
qs.Filter("name", "slene")
qs.Filter("name__exact", "slene")
qs.Filter("profile_id", nil)
1.2.2. iexact
qs.Filter("name__iexact", "slene")
1.2.3. contains
qs.Filter("name__contains", "slene")
1.2.4. icontains
qs.Filter("name__icontains", "slene")
1.2.5. in
qs.Filter("age__in", 17, 18, 19, 20)
ids:=[]int{17,18,19,20}
qs.Filter("age__in", ids)
1.2.6. gt / gte
qs.Filter("profile__age__gt", 17)
qs.Filter("profile__age__gte", 18)
1.2.7. lt / lte
qs.Filter("profile__age__lt", 17)
qs.Filter("profile__age__lte", 18)
1.2.8. startswith
qs.Filter("name__startswith", "slene")
1.2.9. istartswith
qs.Filter("name__istartswith", "slene")
1.2.10. endswith
qs.Filter("name__endswith", "slene")
1.2.11. iendswith
qs.Filter("name__iendswithi", "slene")
1.2.12. isnull
qs.Filter("profile__isnull", true)
qs.Filter("profile_id__isnull", true)
qs.Filter("profile__isnull", false)
1.3. 高级查询接口使用
QuerySeter 是高级查询使用的接口，我们来熟悉下他的接口方法
-
type QuerySeter interface {
- Filter(string, ...interface{}) QuerySeter
- Exclude(string, ...interface{}) QuerySeter
- SetCond(*Condition) QuerySeter
- Limit(int, ...int64) QuerySeter
- Offset(int64) QuerySeter
- GroupBy(...string) QuerySeter
- OrderBy(...string) QuerySeter
- Distinct() QuerySeter
- RelatedSel(...interface{}) QuerySeter
- Count() (int64, error)
- Exist() bool
- Update(Params) (int64, error)
- Delete() (int64, error)
- PrepareInsert() (Inserter, error)
- All(interface{}, ...string) (int64, error)
- One(interface{}, ...string) error
- Values(*[]Params, ...string) (int64, error)
- ValuesList(*[]ParamsList, ...string) (int64, error)
- ValuesFlat(*ParamsList, string) (int64, error)
-
}
-
每个返回 QuerySeter 的 api 调用时都会新建一个 QuerySeter，不影响之前创建的。
-
高级查询使用 Filter 和 Exclude 来做常用的条件查询。囊括两种清晰的过滤规则：包含， 排除
1.3.1. Filter
用来过滤查询结果，起到 包含条件 的作用
多个 Filter 之间使用 AND 连接
qs.Filter("profile__isnull", true).Filter("name", "slene")
1.3.2. Exclude
用来过滤查询结果，起到 排除条件 的作用
使用 NOT 排除条件
多个 Exclude 之间使用 AND 连接
qs.Exclude("profile__isnull", true).Filter("name", "slene")
1.3.3. SetCond
自定义条件表达式
cond := orm.NewCondition()
cond1 := cond.And("profile__isnull", false).AndNot("status__in", 1).Or("profile__age__gt", 2000)
qs := orm.QueryTable("user")
qs = qs.SetCond(cond1)
cond2 := cond.AndCond(cond1).OrCond(cond.And("name", "slene"))
qs = qs.SetCond(cond2).Count()
1.3.4. Limit
限制最大返回数据行数，第二个参数可以设置 Offset
var DefaultRowsLimit = 1000
qs.Limit(10)
qs.Limit(10, 20)
qs.Limit(-1)
qs.Limit(-1, 100)
1.3.5. Offset
设置 偏移行数
qs.Offset(20)
1.3.6. GroupBy
qs.GroupBy("id", "age")
1.3.7. OrderBy
参数使用 expr
在 expr 前使用减号 - 表示 DESC 的排列
qs.OrderBy("id", "-profile__age")
qs.OrderBy("-profile__age", "profile")
1.3.8. Distinct
对应 sql 的 distinct 语句, 返回不重复的值.
qs.Distinct()
关系查询，参数使用 expr
var DefaultRelsDepth = 5
qs := o.QueryTable("post")
qs.RelatedSel()
qs.RelatedSel("user")
1.3.10. Count
依据当前的查询条件，返回结果行数
cnt, err := o.QueryTable("user").Count()
fmt.Printf("Count Num: %s, %s", cnt, err)
1.3.11. Exist
exist := o.QueryTable("user").Filter("UserName", "Name").Exist()
fmt.Printf("Is Exist: %s", exist)
1.3.12. Update
依据当前查询条件，进行批量更新操作
num, err := o.QueryTable("user").Filter("name", "slene").Update(orm.Params{
"name": "astaxie",
})
fmt.Printf("Affected Num: %s, %s", num, err)
原子操作增加字段值
num, err := o.QueryTable("user").Update(orm.Params{
"nums": orm.ColValue(orm.ColAdd, 100),
})
orm.ColValue 支持以下操作
ColAdd
ColMinus
ColMultiply
ColExcept
1.3.13. Delete
依据当前查询条件，进行批量删除操作
num, err := o.QueryTable("user").Filter("name", "slene").Delete()
fmt.Printf("Affected Num: %s, %s", num, err)
1.3.14. PrepareInsert
用于一次 prepare 多次 insert 插入，以提高批量插入的速度。
var users []*User
...
qs := o.QueryTable("user")
i, _ := qs.PrepareInsert()
for _, user := range users {
id, err := i.Insert(user)
if err == nil {
...
}
}
i.Close()
1.3.15. All
返回对应的结果集对象
All 的参数支持 []Type 和 []*Type 两种形式的 slice
var users []*User
num, err := o.QueryTable("user").Filter("name", "slene").All(&users)
fmt.Printf("Returned Rows Num: %s, %s", num, err)
All / Values / ValuesList / ValuesFlat 受到 Limit 的限制，默认最大行数为 1000
可以指定返回的字段：
type Post struct {
Id int
Title string
Content string
Status int
}
var posts []Post
o.QueryTable("post").Filter("Status", 1).All(&posts, "Id", "Title")
对象的其他字段值将会是对应类型的默认值
1.3.16. One
尝试返回单条记录
var user User
err := o.QueryTable("user").Filter("name", "slene").One(&user)
if err == orm.ErrMultiRows {
fmt.Printf("Returned Multi Rows Not One")
}
if err == orm.ErrNoRows {
fmt.Printf("Not row found")
}
可以指定返回的字段：
var post Post
o.QueryTable("post").Filter("Content__istartswith", "prefix string").One(&post, "Id", "Title")
对象的其他字段值将会是对应类型的默认值
1.3.17. Values
返回结果集的 key => value 值
key 为 Model 里的 Field name, value 的值是 interface{} 类型, 例如，如果你要将 value 赋值给 struct 中的某字段，需要根据结构体对应字段类型使用断言获取真实值。举例:Name : m["Name"].(string)
var maps []orm.Params
num, err := o.QueryTable("user").Values(&maps)
if err == nil {
fmt.Printf("Result Nums: %d\n", num)
for _, m := range maps {
fmt.Println(m["Id"], m["Name"])
}
}
返回指定的 Field 数据
TODO: 暂不支持级联查询 RelatedSel 直接返回 Values
但可以直接指定 expr 级联返回需要的数据
var maps []orm.Params
num, err := o.QueryTable("user").Values(&maps, "id", "name", "profile", "profile__age")
if err == nil {
fmt.Printf("Result Nums: %d\n", num)
for _, m := range maps {
fmt.Println(m["Id"], m["Name"], m["Profile"], m["Profile__Age"])
}
}
1.3.18. ValuesList
顾名思义，返回的结果集以 slice 存储
结果的排列与 Model 中定义的 Field 顺序一致
返回的每个元素值以 string 保存
var lists []orm.ParamsList
num, err := o.QueryTable("user").ValuesList(&lists)
if err == nil {
fmt.Printf("Result Nums: %d\n", num)
for _, row := range lists {
fmt.Println(row)
}
}
当然也可以指定 expr 返回指定的 Field
var lists []orm.ParamsList
num, err := o.QueryTable("user").ValuesList(&lists, "name", "profile__age")
if err == nil {
fmt.Printf("Result Nums: %d\n", num)
for _, row := range lists {
fmt.Printf("Name: %s, Age: %s\m", row[0], row[1])
}
}
1.3.19. ValuesFlat
只返回特定的 Field 值，将结果集展开到单个 slice 里
var list orm.ParamsList
num, err := o.QueryTable("user").ValuesFlat(&list, "name")
if err == nil {
fmt.Printf("Result Nums: %d\n", num)
fmt.Printf("All User Names: %s", strings.Join(list, ", "))
}
1.4. 关系查询
以例子里的模型定义来看下怎么进行关系查询
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)
fmt.Println(user.Profile)
fmt.Println(user.Profile.User)
通过 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)
}
}
根据 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)
1.5. 载入关系字段
LoadRelated 用于载入模型的关系字段，包括所有的 rel/reverse - one/many 关系
ManyToMany 关系字段载入
post := Post{Id: 1}
err := o.Read(&post)
num, err := o.LoadRelated(&post, "Tags")
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 {
}
1.6. 多对多关系操作
- type QueryM2Mer interface {
- }
创建一个 QueryM2Mer 对象
o := orm.NewOrm()
post := Post{Id: 1}
m2m := o.QueryM2M(&post, "Tags")
1.6.1. QueryM2Mer 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
...
...
num, err := m2m.Add(tags)
if err == nil {
fmt.Println("Added nums: ", num)
}
1.6.2. QueryM2Mer Remove
从 M2M 关系中删除 tag
Remove 支持多种类型 Tag _Tag []_Tag []Tag []interface{}
var tags []*Tag
...
...
num, err := m2m.Remove(tags)
if err == nil {
fmt.Println("Removed nums: ", num)
}
1.6.3. QueryM2Mer Exist
判断 Tag 是否存在于 M2M 关系中
if m2m.Exist(&Tag{Id: 2}) {
fmt.Println("Tag Exist")
}
1.6.4. QueryM2Mer Clear
清除所有 M2M 关系
nums, err := m2m.Clear()
if err == nil {
fmt.Println("Removed Tag Nums: ", nums)
}
1.6.5. QueryM2Mer Count
计算 Tag 的数量
nums, err := m2m.Count()
if err == nil {
fmt.Println("Total Nums: ", nums)
}
