閱讀(675) 書(shū)簽贊(0) 我要糾錯(cuò)

beego高級(jí)查詢

2023-11-20 18:07 更新

ORM 以 QuerySeter 來(lái)組織查詢，每個(gè)返回 QuerySeter 的方法都會(huì)獲得一個(gè)新的 QuerySeter 對(duì)象。

基本使用方法:

o := orm.NewOrm()

// 獲取 QuerySeter 對(duì)象，user 為表名
qs := o.QueryTable("user")

// 也可以直接使用對(duì)象作為表名
user := new(User)
qs = o.QueryTable(user) // 返回 QuerySeter

expr

QuerySeter 中用于描述字段和 sql 操作符，使用簡(jiǎn)單的 expr 查詢方法

字段組合的前后順序依照表的關(guān)系，比如 User 表?yè)碛?Profile 的外鍵，那么對(duì) User 表查詢對(duì)應(yīng)的 Profile.Age 為條件，則使用 Profile__Age 注意，字段的分隔符號(hào)使用雙下劃線 __，除了描述字段， expr 的尾部可以增加操作符以執(zhí)行對(duì)應(yīng)的 sql 操作。比如 Profile__Age__gt 代表 Profile.Age > 18 的條件查詢。

注釋后面將描述對(duì)應(yīng)的 sql 語(yǔ)句，僅僅是描述 expr 的類似結(jié)果，并不代表實(shí)際生成的語(yǔ)句。

qs.Filter("id", 1) // WHERE id = 1
qs.Filter("profile__age", 18) // WHERE profile.age = 18
qs.Filter("Profile__Age", 18) // 使用字段名和 Field 名都是允許的
qs.Filter("profile__age", 18) // WHERE profile.age = 18
qs.Filter("profile__age__gt", 18) // WHERE profile.age > 18
qs.Filter("profile__age__gte", 18) // WHERE profile.age >= 18
qs.Filter("profile__age__in", 18, 20) // WHERE profile.age IN (18, 20)

qs.Filter("profile__age__in", 18, 20).Exclude("profile__lt", 1000)
// WHERE profile.age IN (18, 20) AND NOT profile_id < 1000

Operators

當(dāng)前支持的操作符號(hào)：

exact / iexact 等于
contains / icontains 包含
gt / gte 大于 / 大于等于
lt / lte 小于 / 小于等于
startswith / istartswith 以...起始
endswith / iendswith 以...結(jié)束
in
isnull

后面以 i 開(kāi)頭的表示：大小寫(xiě)不敏感

exact

Filter / Exclude / Condition expr 的默認(rèn)值

qs.Filter("name", "slene") // WHERE name = 'slene'
qs.Filter("name__exact", "slene") // WHERE name = 'slene'
// 使用 = 匹配，大小寫(xiě)是否敏感取決于數(shù)據(jù)表使用的 collation
qs.Filter("profile_id", nil) // WHERE profile_id IS NULL

iexact

qs.Filter("name__iexact", "slene")
// WHERE name LIKE 'slene'
// 大小寫(xiě)不敏感，匹配任意 'Slene' 'sLENE'

contains

qs.Filter("name__contains", "slene")
// WHERE name LIKE BINARY '%slene%'
// 大小寫(xiě)敏感, 匹配包含 slene 的字符

icontains

qs.Filter("name__icontains", "slene")
// WHERE name LIKE '%slene%'
// 大小寫(xiě)不敏感, 匹配任意 'im Slene', 'im sLENE'

in

qs.Filter("age__in", 17, 18, 19, 20)
// WHERE age IN (17, 18, 19, 20)


ids:=[]int{17,18,19,20}
qs.Filter("age__in", ids)
// WHERE age IN (17, 18, 19, 20)

// 同上效果

gt / gte

qs.Filter("profile__age__gt", 17)
// WHERE profile.age > 17

qs.Filter("profile__age__gte", 18)
// WHERE profile.age >= 18

lt / lte

qs.Filter("profile__age__lt", 17)
// WHERE profile.age < 17

qs.Filter("profile__age__lte", 18)
// WHERE profile.age <= 18

startswith

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

istartswith

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

endswith

qs.Filter("name__endswith", "slene")
// WHERE name LIKE BINARY '%slene'
// 大小寫(xiě)敏感, 匹配以 'slene' 結(jié)束的字符串

iendswith

qs.Filter("name__iendswithi", "slene")
// WHERE name LIKE '%slene'
// 大小寫(xiě)不敏感, 匹配任意以 'slene', 'Slene' 結(jié)束的字符串

isnull

qs.Filter("profile__isnull", true)
qs.Filter("profile_id__isnull", true)
// WHERE profile_id IS NULL

qs.Filter("profile__isnull", false)
// WHERE profile_id IS NOT NULL

高級(jí)查詢接口使用

QuerySeter 是高級(jí)查詢使用的接口，我們來(lái)熟悉下他的接口方法

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)
}
每個(gè)返回 QuerySeter 的 api 調(diào)用時(shí)都會(huì)新建一個(gè) QuerySeter，不影響之前創(chuàng)建的。
高級(jí)查詢使用 Filter 和 Exclude 來(lái)做常用的條件查詢。囊括兩種清晰的過(guò)濾規(guī)則：包含，排除

Filter

用來(lái)過(guò)濾查詢結(jié)果，起到包含條件的作用

多個(gè) Filter 之間使用 AND 連接

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

Exclude

用來(lái)過(guò)濾查詢結(jié)果，起到排除條件的作用

使用 NOT 排除條件

多個(gè) Exclude 之間使用 AND 連接

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

SetCond

自定義條件表達(dá)式

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)
// WHERE ... AND ... AND NOT ... OR ...

cond2 := cond.AndCond(cond1).OrCond(cond.And("name", "slene"))
qs = qs.SetCond(cond2).Count()
// WHERE (... AND ... AND NOT ... OR ...) OR ( ... )

Limit

限制最大返回?cái)?shù)據(jù)行數(shù)，第二個(gè)參數(shù)可以設(shè)置 Offset

var DefaultRowsLimit = 1000 // ORM 默認(rèn)的 limit 值為 1000

// 默認(rèn)情況下 select 查詢的最大行數(shù)為 1000
// LIMIT 1000

qs.Limit(10)
// LIMIT 10

qs.Limit(10, 20)
// LIMIT 10 OFFSET 20 注意跟 SQL 反過(guò)來(lái)的

qs.Limit(-1)
// no limit

qs.Limit(-1, 100)
// LIMIT 18446744073709551615 OFFSET 100
// 18446744073709551615 是 1<<64 - 1 用來(lái)指定無(wú) limit 限制 但有 offset 偏移的情況

Offset

設(shè)置偏移行數(shù)

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

GroupBy

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

OrderBy

參數(shù)使用 expr

在 expr 前使用減號(hào) - 表示 DESC 的排列

qs.OrderBy("id", "-profile__age")
// ORDER BY id ASC, profile.age DESC

qs.OrderBy("-profile__age", "profile")
// ORDER BY profile.age DESC, profile_id ASC

Distinct

對(duì)應(yīng) sql 的 distinct 語(yǔ)句, 返回不重復(fù)的值.

qs.Distinct()
// SELECT DISTINCT

RelatedSel

關(guān)系查詢，參數(shù)使用 expr

var DefaultRelsDepth = 5 // 默認(rèn)情況下直接調(diào)用 RelatedSel 將進(jìn)行最大 5 層的關(guān)系查詢

qs := o.QueryTable("post")

qs.RelatedSel()
// INNER JOIN user ... LEFT OUTER JOIN profile ...

qs.RelatedSel("user")
// INNER JOIN user ...
// 設(shè)置 expr 只對(duì)設(shè)置的字段進(jìn)行關(guān)系查詢

// 對(duì)設(shè)置 null 屬性的 Field 將使用 LEFT OUTER JOIN

Count

依據(jù)當(dāng)前的查詢條件，返回結(jié)果行數(shù)

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

Exist

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

Update

依據(jù)當(dāng)前查詢條件，進(jìn)行批量更新操作

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

原子操作增加字段值

// 假設(shè) user struct 里有一個(gè) nums int 字段
num, err := o.QueryTable("user").Update(orm.Params{
    "nums": orm.ColValue(orm.ColAdd, 100),
})
// SET nums = nums + 100

orm.ColValue 支持以下操作

ColAdd      // 加
ColMinus    // 減
ColMultiply // 乘
ColExcept   // 除

Delete

依據(jù)當(dāng)前查詢條件，進(jìn)行批量刪除操作

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

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 {
        ...
    }
}
// PREPARE INSERT INTO user (`name`, ...) VALUES (?, ...)
// EXECUTE INSERT INTO user (`name`, ...) VALUES ("slene", ...)
// EXECUTE ...
// ...
i.Close() // 別忘記關(guān)閉 statement

All

返回對(duì)應(yīng)的結(jié)果集對(duì)象

All 的參數(shù)支持 []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 的限制，默認(rèn)最大行數(shù)為 1000

可以指定返回的字段：

type Post struct {
    Id      int
    Title   string
    Content string
    Status  int
}

// 只返回 Id 和 Title
var posts []Post
o.QueryTable("post").Filter("Status", 1).All(&posts, "Id", "Title")

對(duì)象的其他字段值將會(huì)是對(duì)應(yīng)類型的默認(rèn)值

One

嘗試返回單條記錄

var user User
err := o.QueryTable("user").Filter("name", "slene").One(&user)
if err == orm.ErrMultiRows {
    // 多條的時(shí)候報(bào)錯(cuò)
    fmt.Printf("Returned Multi Rows Not One")
}
if err == orm.ErrNoRows {
    // 沒(méi)有找到記錄
    fmt.Printf("Not row found")
}

可以指定返回的字段：

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

對(duì)象的其他字段值將會(huì)是對(duì)應(yīng)類型的默認(rèn)值

Values

返回結(jié)果集的 key => value 值

key 為Model里的Field name, value的值是interface{}類型,例如，如果你要將value賦值給struct中的某字段，需要根據(jù)結(jié)構(gòu)體對(duì)應(yīng)字段類型使用斷言獲取真實(shí)值。舉例: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 數(shù)據(jù)

TODO: 暫不支持級(jí)聯(lián)查詢 RelatedSel 直接返回 Values

但可以直接指定 expr 級(jí)聯(lián)返回需要的數(shù)據(jù)

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"])
        // map 中的數(shù)據(jù)都是展開(kāi)的，沒(méi)有復(fù)雜的嵌套
    }
}

ValuesList

顧名思義，返回的結(jié)果集以slice存儲(chǔ)

結(jié)果的排列與 Model 中定義的 Field 順序一致

返回的每個(gè)元素值以 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)
    }
}

當(dāng)然也可以指定 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])
    }
}

ValuesFlat

只返回特定的 Field 值，將結(jié)果集展開(kāi)到單個(gè) 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, ", "))
}

關(guān)系查詢

以例子里的模型定義來(lái)看下怎么進(jìn)行關(guān)系查詢

User 和 Profile 是 OneToOne 的關(guān)系

已經(jīng)取得了 User 對(duì)象，查詢 Profile：

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

直接關(guān)聯(lián)查詢：

user := &User{}
o.QueryTable("user").Filter("Id", 1).RelatedSel().One(user)
// 自動(dòng)查詢到 Profile
fmt.Println(user.Profile)
// 因?yàn)樵?Profile 里定義了反向關(guān)系的 User，所以 Profile 里的 User 也是自動(dòng)賦值過(guò)的，可以直接取用。
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`

通過(guò) User 反向查詢 Profile：

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

Post 和 User 是 ManyToOne 關(guān)系，也就是 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`

根據(jù) Post.Title 查詢對(duì)應(yīng)的 User：

RegisterModel 時(shí)，ORM 也會(huì)自動(dòng)建立 User 中 Post 的反向關(guān)系，所以可以直接進(jìn)行查詢

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 關(guān)系

設(shè)置 rel(m2m) 以后，ORM 會(huì)自動(dòng)創(chuàng)建中間表

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 紀(jì)錄可能對(duì)應(yīng)不同的 Tag 紀(jì)錄,一條 Tag 紀(jì)錄可能對(duì)應(yīng)不同的 Post 紀(jì)錄，所以 Post 和 Tag 屬于多對(duì)多關(guān)系,通過(guò) tag name 查詢哪些 post 使用了這個(gè) tag

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

通過(guò) post title 查詢這個(gè) post 有哪些 tag

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

載入關(guān)系字段

LoadRelated 用于載入模型的關(guān)系字段，包括所有的 rel/reverse - one/many 關(guān)系

ManyToMany 關(guān)系字段載入

// 載入相應(yīng)的 Tags
post := Post{Id: 1}
err := o.Read(&post)
num, err := o.LoadRelated(&post, "Tags")

// 載入相應(yīng)的 Posts
tag := Tag{Id: 1}
err := o.Read(&tag)
num, err := o.LoadRelated(&tag, "Posts")

User 是 Post 的 ForeignKey，對(duì)應(yīng)的 ReverseMany 關(guān)系字段載入

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 {
    //...
}

多對(duì)多關(guān)系操作

type QueryM2Mer interface {Add(...interface{}) (int64, error)Remove(...interface{}) (int64, error)Exist(interface{}) bool Clear() (int64, error)Count() (int64, error)
}

創(chuàng)建一個(gè) QueryM2Mer 對(duì)象

o := orm.NewOrm()
post := Post{Id: 1}
m2m := o.QueryM2M(&post, "Tags")
// 第一個(gè)參數(shù)的對(duì)象，主鍵必須有值
// 第二個(gè)參數(shù)為對(duì)象需要操作的 M2M 字段
// QueryM2Mer 的 api 將作用于 Id 為 1 的 Post

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
...
// 讀取 tags 以后
...
num, err := m2m.Add(tags)
if err == nil {
    fmt.Println("Added nums: ", num)
}
// 也可以多個(gè)作為參數(shù)傳入
// m2m.Add(tag1, tag2, tag3)

QueryM2Mer Remove

從M2M關(guān)系中刪除 tag

Remove 支持多種類型 Tag Tag []Tag []Tag []interface{}

var tags []*Tag
...
// 讀取 tags 以后
...
num, err := m2m.Remove(tags)
if err == nil {
    fmt.Println("Removed nums: ", num)
}
// 也可以多個(gè)作為參數(shù)傳入
// m2m.Remove(tag1, tag2, tag3)

QueryM2Mer Exist

判斷 Tag 是否存在于 M2M 關(guān)系中

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

QueryM2Mer Clear

清除所有 M2M 關(guān)系

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

QueryM2Mer Count

計(jì)算 Tag 的數(shù)量

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

以上內(nèi)容是否對(duì)您有幫助：

← beego的CRUD操作

beego原生SQL查詢 →

寫(xiě)筆記

我要補(bǔ)充