ORM以QuerySeter來組織查詢,每個返回QuerySeter的方法都會獲得一個新的QuerySeter對象。
# 基本使用方法:
```
o := orm.NewOrm()
// 獲取 QuerySeter 對象,user 為表名
qs := o.QueryTable("user")
// 也可以直接使用對象作為表名
user := new(User)
qs = o.QueryTable(user) // 返回 QuerySeter
```
# 1.expr
QuerySeter中用于描述字段和sql操作符,使用簡單的expr查詢方法。
字段組合的其后順序依照表的關系,比如User表擁有Profile的外鍵,那么對User表查詢對應的Profile.Age為條件,則使用profile\_\_Age,
注意字段的分隔符使用雙下劃線\_\_,除了描述字段,expr的尾部可以增加操作符以執行對應的sql操作。比如profile\_\_Age\_\_gt代表profile.Age > 18的條件查詢。
```
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
```
# **2.operators**
當前支持的操作符號
* exact?/?iexact?等于
* contains?/?icontains?包含
* gt / gte?大于 / 大于等于
* lt / lte?小于 / 小于等于
* startswith?/?istartswith?以…起始
* endswith?/?iendswith?以…結束
* in
* isnull
后面以i開頭的表示:不區分大小寫。
### (1)exact
Filter / Exclude / Condition expr 的默認值
```
qs.Filter("name", "slene") // WHERE name = 'slene'
qs.Filter("name\_\_exact", "slene") // WHERE name = 'slene'
// 使用 = 匹配,大小寫是否敏感取決于數據表使用的 collation
qs.Filter("profile\_id", nil) // WHERE profile\_id IS NULL
```
### (2)iexact
```
qs.Filter("name\_\_iexact", "slene")
// WHERE name LIKE 'slene'
// 大小寫不敏感,匹配任意 'Slene' 'sLENE'
```
### (3)contains
```
qs.Filter("name\_\_contains", "slene")
// WHERE name LIKE BINARY '%slene%'
// 大小寫敏感, 匹配包含 slene 的字符
```
### (4)icontains
```
qs.Filter("name\_\_icontains", "slene")
// WHERE name LIKE '%slene%'
// 大小寫不敏感, 匹配任意 'im Slene', 'im sLENE'
```
### (5)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)
// 同上效果
```
### (6)gt/gte
```
qs.Filter("profile\_\_age\_\_gt", 17)
// WHERE profile.age > 17
qs.Filter("profile\_\_age\_\_gte", 18)
// WHERE profile.age >= 18
```
### (7)li/lte
```
qs.Filter("profile\_\_age\_\_lt", 17)
// WHERE profile.age < 17
qs.Filter("profile\_\_age\_\_lte", 18)
// WHERE profile.age <= 18
```
### (8)startswith
```
qs.Filter("name\_\_startswith", "slene")
// WHERE name LIKE BINARY 'slene%'
// 大小寫敏感, 匹配以 'slene' 起始的字符串
```
### (9)istartwith
```
qs.Filter("name\_\_istartswith", "slene")
// WHERE name LIKE 'slene%'
// 大小寫不敏感, 匹配任意以 'slene', 'Slene' 起始的字符串
```
### (10)endswith
```
qs.Filter("name\_\_endswith", "slene")
// WHERE name LIKE BINARY '%slene'
// 大小寫敏感, 匹配以 'slene' 結束的字符串
```
### (11)iendswith
```
qs.Filter("name\_\_iendswithi", "slene")
// WHERE name LIKE '%slene'
// 大小寫不敏感, 匹配任意以 'slene', 'Slene' 結束的字符串
```
### (12)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(2)iexact
qs.Filter("name\_\_iexact", "slene")
// WHERE name LIKE 'slene'
// 大小寫不敏感,匹配任意 'Slene' 'sLENE'
```
# 高級查詢
使用Filter和Exclude來做常用的條件查詢,囊括兩種清晰的過濾規則:包含、排除
## (1)Filter
用來過濾查詢結果,起到包含條件的作用,多個Filter之間使用AND連接。
```
qs.Filter("profile\_\_isnull", true).Filter("name", "slene")
// WHERE profile\_id IS NULL AND name = 'slene'
```
## (2)Exclude
用來過濾查詢結果,起到排除條件的作用。
使用NOT排除條件,多個Exclude之間使用AND連接。
```
qs.Exclude("profile\_\_isnull", true).Filter("name", "slene")
// WHERE NOT profile\_id IS NULL AND name = 'slene'
```
## (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)
// 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 ( ... )
```
##
## (4)Limit
限制最大返回數據行數,第二個參數可以設置為Offset
```
var DefaultRowsLimit = 1000 // ORM 默認的 limit 值為 1000
// 默認情況下 select 查詢的最大行數為 1000
// LIMIT 1000
qs.Limit(10)
// LIMIT 10
qs.Limit(10, 20)
// LIMIT 10 OFFSET 20 注意跟 SQL 反過來的
qs.Limit(-1)
// no limit
qs.Limit(-1, 100)
// LIMIT 18446744073709551615 OFFSET 100
// 18446744073709551615 是 1<<64 - 1 用來指定無 limit 限制 但有 offset 偏移的情況
```
## (5)Offset
設置偏移行數
```
qs.Offset(20)
// LIMIT 1000 OFFSET 20
```
## (6)GroupBy
```
qs.GroupBy("id", "age")
// GROUP BY id,age
```
## (7)OrderBy
在expr前使用減號-表示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
```
## (8)Distinct
對應sql的distinct語句,返回不重復的值
```
qs.Distinct()
// SELECT DISTINCT
```
## (9)RelatedSel
關系查詢,參數使用 expr
```
var DefaultRelsDepth = 5 // 默認情況下直接調用 RelatedSel 將進行最大 5 層的關系查詢
qs := o.QueryTable("post")
qs.RelatedSel()
// INNER JOIN user ... LEFT OUTER JOIN profile ...
qs.RelatedSel("user")
// INNER JOIN user ...
// 設置 expr 只對設置的字段進行關系查詢
// 對設置 null 屬性的 Field 將使用 LEFT OUTER JOIN
```
## (10)Count
依據當前的查詢條件,返回結果行數
```
cnt, err := o.QueryTable("user").Count() // SELECT COUNT(\*) FROM USER
fmt.Printf("Count Num: %s, %s", cnt, err)
```
## (11)Exist
```
exist := o.QueryTable("user").Filter("UserName", "Name").Exist()
fmt.Printf("Is Exist: %s", exist)
```
## (12)Update
依據當前查詢條件,進行批量更新操作
```
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"
```
原子操作增加字段值
```
// 假設 user struct 里有一個 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 // 除
```
## (13)Delete
依據當前查詢條件,進行批量刪除操作
```
num, err := o.QueryTable("user").Filter("name", "slene").Delete()
fmt.Printf("Affected Num: %s, %s", num, err)
// DELETE FROM user WHERE name = "slene"
```
## (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 {
...
}
}
// PREPARE INSERT INTO user (`name`, ...) VALUES (?, ...)
// EXECUTE INSERT INTO user (`name`, ...) VALUES ("slene", ...)
// EXECUTE ...
// ...
i.Close() // 別忘記關閉 statement
```
## (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
}
// 只返回 Id 和 Title
var posts[]Post
o.QueryTable("post").Filter("Status", 1).All(&posts, "Id", "Title")
```
對象的其它字段值將會是對應類型的默認值。
## (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")
}
```
可以指定返回的字段。
```
// 只返回 Id 和 Title
var post Post
o.QueryTable("post").Filter("Content\_\_istartswith", "prefix string").One(&post, "Id", "Title")
```
對象的其它字段值將會是對應類型的默認值。
## (17)Values
以鍵值對的方式返回結果集。key 為 Model 里的 Field name,value 的值 以 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"])
// map 中的數據都是展開的,沒有復雜的嵌套
}
}
```
## (18)ValueList
顧名思義,返回的結果集以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])
}
}
```
```
(19)ValueFlat
```
只返回特定的 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, ", "))
}
```
# 4.關系查詢
## (1)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)
}
```
## (2)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)
}
```
## (3)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)
```
5.載入關系字段
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 {
//...
}
```
6.多對多關系操作
```
type QueryM2Mer interface {
Add(…interface{}) (int64, error)
Remove(…interface{}) (int64, error)
Exist(interface{}) bool
Clear() (int64, error)
Count() (int64, error)
}
```
創建一個 QueryM2Mer 對象
```
o := orm.NewOrm()
post := Post{Id: 1}
m2m := o.QueryM2M(&post, "Tags")
// 第一個參數的對象,主鍵必須有值
// 第二個參數為對象需要操作的 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)
}
// 也可以多個作為參數傳入
// m2m.Add(tag1, tag2, tag3)
```
QueryM2Mer 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)
```
QueryM2Mer Exist
判斷 Tag 是否存在于 M2M 關系中
```
if m2m.Exist(&Tag{Id: 2}) {
fmt.Println("Tag Exist")
}
```
QueryM2Mer Clear
清除所有 M2M 關系
```
nums, err := m2m.Clear()
if err == nil {
fmt.Println("Removed Tag Nums: ", nums)
}
```
QueryM2Mer Count
計算 Tag 的數量
```
nums, err := m2m.Count()
if err == nil {
fmt.Println("Total Nums: ", nums)
}
```
- go環境搭建
- 解決go get網絡慢的問題
- beego的安裝
- bee的安裝
- 編輯器
- go module
- 配置文件詳解
- 配置文件其他說明
- 路由方法
- 路由
- 數據校驗
- 校驗函數
- 頁面跳轉
- 獲取前端數據
- json文件的獲取
- xsrf的用法
- xsrf的防護
- srfs和json的搭配
- flash的用法
- 過濾器
- url反轉
- 各類數據的處理
- 模板函數
- 內置模板函數
- 自定義模板函數
- 模板
- 模板處理
- 模板渲染
- 視圖文件的處理
- 靜態文件
- 請求方式判斷
- 驗證碼
- 另一種方法
- 分頁類
- session
- 登錄判斷
- orm模塊
- 使用方法
- mysql的安裝
- 安裝orm及驅動
- 建立模型
- 自定義模型
- 增刪改查
- 高級查詢
- 常見問題匯總
- 代碼收藏
- 打包部署
- go build打包
- utils收藏
- 新goer容易犯的錯
- 字符串操作