[Beego模型] 一、ORM 使用方法

[Beego模型] 二、CRUD 操作

[Beego模型] 三、高级查询

[Beego模型] 四、使用SQL语句进行查询

[Beego模型] 五、构造查询

[Beego模型] 六、事务处理

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

基本使用方法:

o := orm.NewOrm()// 获取 QuerySeter 对象，user 为表名
qs := o.QueryTable("user")// 也可以直接使用对象作为表名
user := new(User)
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 的类似结果，并不代表实际生成的语句。

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

当前支持的操作符号：

  • exact / iexact 等于
  • contains / icontains 包含
  • gt / gte 大于 / 大于等于
  • lt / lte 小于 / 小于等于
  • startswith / istartswith 以…起始
  • endswith / iendswith 以…结束
  • in
  • isnull

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

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

iexact

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

contains

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

icontains

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

in

qs.Filter("profile__age__in", 17, 18, 19, 20)
// WHERE profile.age IN (17, 18, 19, 20)ids:=[]int{17,18,19,20}
qs.Filter("profile__age__in", ids)
// WHERE profile.age IN (17, 18, 19, 20)// 同上效果

gt / gte

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

lt / lte

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

startswith

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

istartswith

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

endswith

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

iendswith

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

isnull

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

高级查询接口使用

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 来做常用的条件查询。囊括两种清晰的过滤规则：包含， 排除

Filter

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

多个 Filter 之间使用 AND 连接

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

Exclude

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

使用 NOT 排除条件

多个 Exclude 之间使用 AND 连接

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

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 ( ... )

Limit

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

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

Offset

设置 偏移行数

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

GroupBy

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

OrderBy

参数使用 expr

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

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

Distinct

对应 sql 的 distinct 语句, 返回不重复的值.

qs.Distinct()
// SELECT DISTINCT

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

Count

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

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

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

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   // 除

Delete

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

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() // 别忘记关闭 statement

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      intTitle   stringContent stringStatus  int
}// 只返回 Id 和 Title
var posts []Post
o.QueryTable("post").Filter("Status", 1).All(&posts, "Id", "Title")

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

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")

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

Values

返回结果集的 key => value 值

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 中的数据都是展开的，没有复杂的嵌套}
}

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])}
}

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, ", "))
}

关系查询

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

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    intTitle stringUser  *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    intTitle stringUser  *User  `orm:"rel(fk)"`Tags  []*Tag `orm:"rel(m2m)"`
}type Tag struct {Id    intName  stringPosts []*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    intName  stringPosts []*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)
    • 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)
}

摘自：https://beego.me/docs/mvc/model/query.md

转载于:https://www.cnblogs.com/52php/p/7380139.html

[Beego模型] 三、高级查询相关推荐

  1. MongoDB 教程三: 高级查询 （SQL到MongoDB映射表）

    查询接口 对于查询操作,MongoDB 提供了 db.collection.find() 方法.这个方法接收查询条件和映射两个条件并且返回一个指向匹配文档的 游标 .你可以使用 limits, ski ...

  2. MongoDB 教程三: 高级查询

    视频:MongoDB 教程三: 高级查询 MongoDB支持的查询语言非常强大,语法规则类似于面向对象的查询语言,可以实现类似关系数据库单表查询的绝大部分功能,并且由于 MongoDB可以支持复杂的数 ...

  3. MySQL简单快速入门 (三)高级查询——JEPLUS软件快速开发平台

    03.SQL高级查询_分组: 1).需求:一条查询,查询出每种商品的最高价格 2).分组的命令:group by 分组字段 3).实现上例: select category_id,max(price) ...

  4. [Beego模型] 五、构造查询

    [Beego模型] 一.ORM 使用方法 [Beego模型] 二.CRUD 操作 [Beego模型] 三.高级查询 [Beego模型] 四.使用SQL语句进行查询 [Beego模型] 五.构造查询 [ ...

  5. Beego脱坑（十四）ORM高级查询

    title: Beego脱坑(十四)ORM高级查询 tags: go,beego,orm author : Clown95 本文将讲述beego ORM的一些高级查询,这也是ORM最核心的部分,本文所 ...

  6. sql 循环处理数据_图文介绍 SQL 的三种查询计划处理模型，Spark 用了其中两个

    我已经在之前的 <一条 SQL 在 Apache Spark 之旅(上)>.<一条 SQL 在 Apache Spark 之旅(中)> 以及 <一条 SQL 在 Apac ...

  7. ORM框架之Spring Data JPA(三）高级查询---复杂查询

    一.spring data jpa高级查询 1.1Specifications动态查询 有时我们在查询某个实体的时候,给定的条件是不固定的,这时就需要动态构建相应的查询语句,在Spring Data ...

  8. mysql子查询sysdate_MySQL T6 数据库操作——查询（三）高级查询

    复习 算术运算符:+ - * / % [针对数值型,select子句,where子句] 查询大于18岁的学生,学生表内存的是生日 birthday where year(sysdate()) - ye ...

  9. neo4j︱Cypher完整案例csv导入、关系联通、高级查询（三）

    图数据库常规的有:neo4j(支持超多语言).JanusGraph/Titan(分布式).Orientdb,google也开源了图数据库Cayley(Go语言构成).PostgreSQL存储RDF格式 ...

最新文章

  1. 小伙在某知名公司的Python面试题详解，希望对各位以后面试有帮助
  2. 【JavaScript从入门到精通】第一课 初探JavaScript魅力-01
  3. 人生哲理名言六十六条
  4. Windows下安装Redis及使用Python操作Redis的方法
  5. 【arduino】在Arduino上运行FreeRTOS操作系统,freeRTOS入门教程helloword
  6. JPA连接Mysql数据库时提示：Table 'jpa.sequence' dosen't exisit
  7. chrome本地文件加载跨域请求
  8. 【学术】2020上的NLP有哪些研究风向？
  9. python中的__new__、__init__和__del__
  10. 看我说PHP之文件上传
  11. MT4 服务器信号,手机实时接收MT4软件指标信号（简单几步设置搞定）
  12. 智慧产业园区标准体系研究报告 附下载
  13. STM32F103C8T6最小系统板原理图+PCB文件
  14. 【原创】RPA在BPO领域的场景分享-中科云创CEO每日分享
  15. 计算机原理与智能－翻译
  16. 微信安卓协议分析笔记
  17. 路径/ ./ ../的区别
  18. python爬取网易云歌单
  19. Java程序设计教程（第三版） 雍俊海 7.3 答案/代码
  20. 计算机控制课程设计论文,计算机控制课程设计论文..doc

热门文章

  1. matlab中用数据拟合圆心,拟合圆并求圆心(matlab)
  2. use IE7 agent on safari 13
  3. MAYA中average normal
  4. python求解典型相关系数_三大相关系数: pearson, spearman, kendall（python示例实现）...
  5. yolox-keras的源码，超越YOLOv5，可以用于训练自己的模型
  6. SGD、Adam优化器
  7. 如何快速学习数据挖掘、机器学习、人工智能？（附资料包）
  8. 货物贸易外汇监测系统 企业版_企业能耗在线监测系统介绍
  9. 天然气压缩因子计算软件_测量天然气用什么流量计？
  10. 查看电脑的CPU个数，核数，逻辑核数