数据查询

Where/And/Or查询条件

这三个方法用于传递查询条件参数,支持的参数为任意的string/map/slice/struct/*struct类型。

Where条件参数推荐使用字符串的参数传递方式(并使用?占位符预处理),因为map/struct类型作为查询参数无法保证顺序性,且在部分情况下(数据库有时会帮助你自动进行查询索引优化),数据库的索引和你传递的查询条件顺序有一定关系。

当使用多个Where方法连接查询条件时,作用同And
此外,当存在多个查询条件时,gdb会默认将多个条件分别使用()符号进行包含,这种设计可以非常友好地支持查询条件分组。

使用示例:

  1. // WHERE `uid`=1
  2. Where("uid=1")
  3. Where("uid", 1)
  4. Where("uid=?", 1)
  5. Where(g.Map("uid" : 1))
  6. // WHERE `uid` <= 1000 AND `age` >= 18
  7. Where(g.Map(
  8. "uid <=" : 1000,
  9. "age >=" : 18,
  10. ))
  11. // WHERE (`uid` <= 1000) AND (`age` >= 18)
  12. Where("uid <=?", 1000).Where("age >=?", 18)
  13. Where("uid <=?", 1000).And("age >=?", 18)
  14. // WHERE `level`=1 OR `money`>=1000000
  15. Where("level=? OR money >=?", 1, 1000000)
  16. // WHERE (`level`=1) OR (`money`>=1000000)
  17. Where("level", 1).Or("money >=", 1000000)
  18. // WHERE `uid` IN(1,2,3)
  19. Where("uid IN(?)", g.Slice{1,2,3})

使用struct参数的示例,其中ormtag用于指定struct属性与表字段的映射关系:

  1. type Condition struct{
  2. Sex int `orm:"sex"`
  3. Age int `orm:"age"`
  4. }
  5. Where(Condition{1, 18})
  6. // WHERE `sex`=1 AND `age`=18

WherePri支持主键的查询条件

WherePri方法的功能同Where,但提供了对表主键的智能识别,常用于根据主键的便捷数据查询。假如user表的主键为uid,我们来看一下WhereWherePri的区别:

  1. // WHERE `uid`=1
  2. Table("user").Where("uid", 1)
  3. Table("user").WherePri(1)
  4. // WHERE `uid` IN(1,2,3)
  5. Table("user").Where("uid", g.Slice{1,2,3})
  6. Table("user").WherePri(g.Slice{1,2,3})

可以看到,当使用WherePri方法且给定参数为单一的参数基本类型或者slice类型时,将会被识别为主键的查询条件值。

All/One/Array/Value/Count数据查询

这四个方法是数据查询比较常用的方法:

  1. All 用于查询并返回多条记录的列表/数组。
  2. One 用于查询并返回单条记录。
  3. Array 用于查询指定字段列的数据,返回数组。
  4. Value 用于查询并返回一个字段值,往往需要结合Fields方法使用。
  5. Count 用于查询并返回记录数。

此外,也可以看得到这四个方法定义中也支持条件参数的直接输入,参数类型与Where方法一致。但需要注意,其中ArrayValue方法的参数中至少应该输入字段参数。例如:

  1. // SELECT `name` FROM `user` WHERE `score`>60
  2. Table("user").Array("name", "score>?", 60)
  3. // SELECT `name` FROM `user` WHERE `uid`=1
  4. Table("user").Value("name", "uid=1")
  5. Table("user").Value("name", "uid", 1)
  6. // SELECT `name` FROM `user` WHERE `uid` IN(1,2,3)
  7. Table("user").Value("name", "uid", g.Slice{1,2,3})

Struct/Structs/Scan数据查询

这三个方法用于便捷地将查询的结果转换为struct/*struct或者[]struct/[]*struct数据。

  1. Struct: 将查询结果转换为一个struct对象,查询结果应当是特定的一条记录,并且pointer参数应当为struct对象的指针地址(*struct或者**struct),使用方式例如:
    1. type User struct {
    2. Id int
    3. Passport string
    4. Password string
    5. NickName string
    6. CreateTime gtime.Time
    7. }
    8. user := new(User)
    9. err := db.Table("user").Where("id", 1).Struct(user)
    或者
    1. user := &User{}
    2. err := db.Table("user").Where("id", 1).Struct(user)
    前两种方式都是预先初始化对象(提前分配内存),推荐的方式:
    1. user := (*User)(nil)
    2. err := db.Table("user").Where("id", 1).Struct(&user)
    这种方式只有在查询到数据的时候才会执行初始化及内存分配。注意在用法上的区别,特别是传递参数类型的差别(前两种方式传递的参数类型是*User,这里传递的参数类型其实是**User)。
  2. Structs: 将多条查询结果集转换为一个[]struct/[]*struct数组,查询结果应当是多条记录组成的结果集,并且pointer应当为数组的指针地址,使用方式例如:
    1. users := ([]User)(nil)
    2. // 或者 var users []User
    3. err := db.Table("user").Structs(&users)
    或者
    1. users := ([]*User)(nil)
    2. // 或者 var user []*User
    3. err := db.Table("user").Structs(&users)
  3. Scan: 该方法会根据输入参数pointer的类型选择调用Struct还是Structs方法。如果结果是特定的一条记录,那么调用Struct方法;如果结果是slice类型则调用Structs方法。

Find*支持主键条件的数据查询

Find*方法包含:FindAll/FindOne/FineValue/FindCount/FindScan,这些方法与All/One/Value/Count/Scan方法的区别在于,当方法直接给定条件参数时,前者的效果与WherePri方法一致;而后者的效果与Where方法一致。也就是说Find*方法的条件参数支持智能主键识别特性。

LeftJoin/RightJoin/InnerJoin关联查询

  1. LeftJoin 左关联查询;
  2. RightJoin 右关联查询;
  3. InnerJoin 内关联查询;

使用示例:

  1. // 查询符合条件的单条记录(第一条)
  2. // SELECT u.*,ud.site FROM user u LEFT JOIN user_detail ud ON u.uid=ud.uid WHERE u.uid=1 LIMIT 1
  3. r, err := db.Table("user u").LeftJoin("user_detail ud", "u.uid=ud.uid").Fields("u.*,ud.site").Where("u.uid", 1).One()
  4. // 查询指定字段值
  5. // SELECT ud.site FROM user u RIGHT JOIN user_detail ud ON u.uid=ud.uid WHERE u.uid=1 LIMIT 1
  6. r, err := db.Table("user u").RightJoin("user_detail ud", "u.uid=ud.uid").Fields("ud.site").Where("u.uid", 1).Value()
  7. // 分组及排序
  8. // SELECT u.*,ud.site FROM user u INNER JOIN user_detail ud ON u.uid=ud.uid GROUP BY city ORDER BY register_time asc
  9. r, err := db.Table("user u").InnerJoin("user_detail ud", "u.uid=ud.uid").Fields("u.*,ud.city").Group("city").Order("register_time asc").All()
  10. // 不使用join的联表查询
  11. // SELECT u.*,ud.city FROM user u,user_detail ud WHERE u.uid=ud.uid
  12. r, err := db.Table("user u,user_detail ud").Where("u.uid=ud.uid").Fields("u.*,ud.city").All()

Group/Order分组与排序

Group方法用于查询分组,Order方法用于查询排序。使用示例:

  1. // SELECT COUNT(*) total,age FROM `user` GROUP BY age
  2. r, err := db.Table("user").Fields("COUNT(*) total,age").Group("age").All()
  3. // SELECT * FROM `student` ORDER BY class asc,course asc,score desc
  4. r, err := db.Table("student").Order("class asc,course asc,score desc").All()

As数据表别名

As方法用于指定模型别名。使用示例:

  1. user := db.Table("user").Safe()
  2. // SELECT * FROM `user` AS u LEFT JOIN `user_detail` as ud ON(ud.id=u.id) WHERE u.id=1 LIMIT 1
  3. r, err := user.As("u").LeftJoin("user_detail as ud", "ud.id=u.id").Where("u.id", 1).One()

示例1, 基本使用

Where + string,条件参数使用字符串和预处理。

  1. // 查询多条记录并使用Limit分页
  2. // SELECT * FROM user WHERE uid>1 LIMIT 0,10
  3. r, err := db.Table("user").Where("uid > ?", 1).Limit(0, 10).All()
  4. // 使用Fields方法查询指定字段
  5. // 未使用Fields方法指定查询字段时,默认查询为*
  6. // SELECT uid,name FROM user WHERE uid>1 LIMIT 0,10
  7. r, err := db.Table("user").Fileds("uid,name").Where("uid > ?", 1).Limit(0, 10).All()
  8. // 支持多种Where条件参数类型
  9. // SELECT * FROM user WHERE uid=1 LIMIT 1
  10. r, err := db.Table("user").Where("u.uid=1",).One()
  11. r, err := db.Table("user").Where("u.uid", 1).One()
  12. r, err := db.Table("user").Where("u.uid=?", 1).One()
  13. // SELECT * FROM user WHERE (uid=1) AND (name='john') LIMIT 1
  14. r, err := db.Table("user").Where("uid", 1).Where("name", "john").One()
  15. r, err := db.Table("user").Where("uid=?", 1).And("name=?", "john").One()
  16. // SELECT * FROM user WHERE (uid=1) OR (name='john') LIMIT 1
  17. r, err := db.Table("user").Where("uid=?", 1).Or("name=?", "john").One()

Where + slice,预处理参数可直接通过slice参数给定。

  1. // SELECT * FROM user WHERE age>18 AND name like '%john%'
  2. r, err := db.Table("user").Where("age>? AND name like ?", g.Slice{18, "%john%"}).All()
  3. // SELECT * FROM user WHERE status=1
  4. r, err := db.Table("user").Where("status=?", g.Slice{1}).All()

Where + map,条件参数使用任意map类型传递。

  1. // SELECT * FROM user WHERE uid=1 AND name='john' LIMIT 1
  2. r, err := db.Table("user").Where(g.Map{"uid" : 1, "name" : "john"}).One()
  3. // SELECT * FROM user WHERE uid=1 AND age>18 LIMIT 1
  4. r, err := db.Table("user").Where(g.Map{"uid" : 1, "age>" : 18}).One()

Where + struct/*structstruct标签支持 orm/json,映射属性到字段名称关系。

  1. type User struct {
  2. Id int `json:"uid"`
  3. UserName string `orm:"name"`
  4. }
  5. // SELECT * FROM user WHERE uid =1 AND name='john' LIMIT 1
  6. r, err := db.Table("user").Where(User{ Id : 1, UserName : "john"}).One()
  7. // SELECT * FROM user WHERE uid =1 LIMIT 1
  8. r, err := db.Table("user").Where(&User{ Id : 1}).One()

以上的查询条件相对比较简单,我们来看一个比较复杂的查询示例。

  1. condition := g.Map{
  2. "title like ?" : "%九寨%",
  3. "online" : 1,
  4. "hits between ? and ?" : g.Slice{1, 10},
  5. "exp > 0" : nil,
  6. "category" : g.Slice{100, 200},
  7. }
  8. result, err := db.Table("article").Where(condition).All()
  9. // SELECT * FROM article WHERE title like '%九寨%' AND online=1 AND hits between 1 and 10 AND exp > 0 AND category IN(100,200)

示例2, select in查询

使用字符串、slice参数类型。当使用slice参数类型时,预处理占位符只需要一个?即可。

  1. // SELECT * FROM user WHERE uid IN(100,10000,90000)
  2. r, err := db.Table("user").Where("uid IN(?,?,?)", 100, 10000, 90000).All()
  3. r, err := db.Table("user").Where("uid", g.Slice{100, 10000, 90000}).All()
  4. // SELECT * FROM user WHERE gender=1 AND uid IN(100,10000,90000)
  5. r, err := db.Table("user").Where("gender=? AND uid IN(?)", 1, g.Slice{100, 10000, 90000}).All()
  6. // SELECT COUNT(*) FROM user WHERE age in(18,50)
  7. r, err := db.Table("user").Where("age IN(?,?)", 18, 50).Count()
  8. r, err := db.Table("user").Where("age", g.Slice{18, 50}).Count()

使用任意map参数类型。

  1. // SELECT * FROM user WHERE gender=1 AND uid IN(100,10000,90000)
  2. r, err := db.Table("user").Where(g.Map{
  3. "gender" : 1,
  4. "uid" : g.Slice{100,10000,90000},
  5. }).All()

使用struct参数类型,注意查询条件的顺序和struct的属性定义顺序有关。

  1. type User struct {
  2. Id []int `orm:"uid"`
  3. Gender int `orm:"gender"`
  4. }
  5. // SELECT * FROM user WHERE uid IN(100,10000,90000) AND gender=1
  6. r, err := db.Table("user").Where(User{
  7. "gender" : 1,
  8. "uid" : []int{100, 10000, 90000},
  9. }).All()

示例3, like查询

  1. // SELECT * FROM user WHERE name like '%john%'
  2. r, err := db.Table("user").Where("name like ?", "%john%").All()
  3. // SELECT * FROM user WHERE birthday like '1990-%'
  4. r, err := db.Table("user").Where("birthday like ?", "1990-%").All()

示例4, sum查询

  1. // SELECT SUM(score) FROM user WHERE uid=1
  2. r, err := db.Table("user").Fields("SUM(score)").Where("uid", 1).Value()

示例5, count查询

  1. // SELECT COUNT(1) FROM user WHERE `birthday`='1990-10-01'
  2. r, err := db.Table("user").Where("birthday", "1990-10-01").Count()
  3. // SELECT COUNT(uid) FROM user WHERE `birthday`='1990-10-01'
  4. r, err := db.Table("user").Fields("uid").Where("birthday", "1990-10-01").Count()

示例6, distinct查询

  1. // SELECT DISTINCT uid,name FROM user
  2. r, err := db.Table("user").Fields("DISTINCT uid,name").All()