ORM 组件提供了一些常用的条件查询方法，并且条件方法支持多种数据类型输入。

  1. func (m *Model) Where(where interface{}, args...interface{}) *Model
  2. func (m *Model) Wheref(format string, args ...interface{}) *Model
  3. func (m *Model) WherePri(where interface{}, args ...interface{}) *Model
  4. func (m *Model) WhereBetween(column string, min, max interface{}) *Model
  5. func (m *Model) WhereLike(column string, like interface{}) *Model
  6. func (m *Model) WhereIn(column string, in interface{}) *Model
  7. func (m *Model) WhereNull(columns ...string) *Model
  8. func (m *Model) WhereLT(column string, value interface{}) *Model
  9. func (m *Model) WhereLTE(column string, value interface{}) *Model
  10. func (m *Model) WhereGT(column string, value interface{}) *Model
  11. func (m *Model) WhereGTE(column string, value interface{}) *Model
  13. func (m *Model) WhereNotBetween(column string, min, max interface{}) *Model
  14. func (m *Model) WhereNotLike(column string, like interface{}) *Model
  15. func (m *Model) WhereNotIn(column string, in interface{}) *Model
  16. func (m *Model) WhereNotNull(columns ...string) *Model
  18. func (m *Model) WhereOr(where interface{}, args ...interface{}) *Model
  19. func (m *Model) WhereOrBetween(column string, min, max interface{}) *Model
  20. func (m *Model) WhereOrLike(column string, like interface{}) *Model
  21. func (m *Model) WhereOrIn(column string, in interface{}) *Model
  22. func (m *Model) WhereOrNull(columns ...string) *Model
  23. func (m *Model) WhereOrLT(column string, value interface{}) *Model
  24. func (m *Model) WhereOrLTE(column string, value interface{}) *Model
  25. func (m *Model) WhereOrGT(column string, value interface{}) *Model
  26. func (m *Model) WhereOrGTE(column string, value interface{}) *Model
  28. func (m *Model) WhereOrNotBetween(column string, min, max interface{}) *Model
  29. func (m *Model) WhereOrNotLike(column string, like interface{}) *Model
  30. func (m *Model) WhereOrNotIn(column string, in interface{}) *Model
  31. func (m *Model) WhereOrNotNull(columns ...string) *Model

下面我们对其中的几个常用方法做简单介绍，其他条件查询方法用法类似。

Where/WhereOr 查询条件

基本介绍

这两个方法用于传递查询条件参数，支持的参数为任意的 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. })
  12. // WHERE (`uid` <= 1000) AND (`age` >= 18)
  13. Where("uid <=?", 1000).Where("age >=?", 18)
  15. // WHERE `level`=1 OR `money`>=1000000
  16. Where("level=? OR money >=?", 1, 1000000)
  18. // WHERE (`level`=1) OR (`money`>=1000000)
  19. Where("level", 1).WhereOr("money >=", 1000000)
  21. // WHERE `uid` IN(1,2,3)
  22. Where("uid IN(?)", g.Slice{1,2,3})

使用 struct 参数的示例，其中 orm 的 tag 用于指定 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

使用示例

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

  1. // 查询多条记录并使用Limit分页
  2. // SELECT * FROM user WHERE uid>1 LIMIT 0,10
  3. g.Model("user").Where("uid > ?", 1).Limit(0, 10).All()
  5. // 使用Fields方法查询指定字段
  6. // 未使用Fields方法指定查询字段时，默认查询为*
  7. // SELECT uid,name FROM user WHERE uid>1 LIMIT 0,10
  8. g.Model("user").Fields("uid,name").Where("uid > ?", 1).Limit(0, 10).All()
  10. // 支持多种Where条件参数类型
  11. // SELECT * FROM user WHERE uid=1 LIMIT 1
  12. g.Model("user").Where("uid=1").One()
  13. g.Model("user").Where("uid", 1).One()
  14. g.Model("user").Where("uid=?", 1).One()
  16. // SELECT * FROM user WHERE (uid=1) AND (name='john') LIMIT 1
  17. g.Model("user").Where("uid", 1).Where("name", "john").One()
  18. g.Model("user").Where("uid=?", 1).Where("name=?", "john").One()
  20. // SELECT * FROM user WHERE (uid=1) OR (name='john') LIMIT 1
  21. g.Model("user").Where("uid=?", 1).WhereOr("name=?", "john").One()

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

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

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

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

Where + struct/*struct， struct 标签支持 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. g.Model("user").Where(User{ Id : 1, UserName : "john"}).One()
  8. // SELECT * FROM user WHERE uid =1 LIMIT 1
  9. g.Model("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. // SELECT * FROM article WHERE title like '%九寨%' AND online=1 AND hits between 1 and 10 AND exp > 0 AND category IN(100,200)
  9. g.Model("article").Where(condition).All()

Wheref 格式化条件字符串

在某些场景中，在输入带有字符串的条件语句时，往往需要结合 fmt.Sprintf 来格式化条件（当然，注意在字符串中使用占位符代替变量的输入而不是直接将变量格式化），因此我们提供了 Where+fmt.Sprintf 结合的便捷方法 Wheref。使用示例：

  1. // WHERE score > 100 and status in('succeeded','completed')
  2. Wheref(`score > ? and status in (?)`, 100, g.Slice{"succeeded", "completed"})

WherePri 支持主键的查询条件

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

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

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

WhereBuilder 复杂条件组合

WhereBuilder 用以组合生成复杂的 Where 条件。

对象创建

我们可以使用 Model 的 Builder 方法生成 WhereBuilder 对象。该方法定义如下：

  1. // Builder creates and returns a WhereBuilder.
  2. func (m *Model) Builder() *WhereBuilder

使用示例

  1. // SELECT * FROM `user` WHERE `id`=1 AND `address`="USA" AND (`status`="active" OR `status`="pending")
  2. m := g.Model("user")
  3. all, err := m.Where("id", 1).Where("address", "USA").Where(
  4.     m.Builder().Where("status", "active").WhereOr("status", "pending"),
  5. ).All()

注意事项：空数组条件引发的 0=1 条件

我们来看例子：

SQL1：

  1. m := g.Model("auth")
  2. m.Where("status", g.Slice{"permitted", "inherited"}).Where("uid", 1).All()
  3. // SELECT * FROM `auth` WHERE (`status` IN('permitted','inherited')) AND (`uid`=1)

SQL2：

  1. m := g.Model("auth")
  2. m.Where("status", g.Slice{}).Where("uid", 1).All()
  3. // SELECT * FROM `auth` WHERE (0=1) AND (`uid`=1)

可以看到，当给定的数组条件为空数组时，生成的 SQL 出现了 0=1 的无效条件，这是为什么呢？

在开发者没有显示声明可以过滤空数组条件时， ORM 不会自动过滤空数组条件，以避免程序逻辑绕过 SQL 限制条件，引发不可预知的业务问题。如果开发者确定 SQL 限制条件是可以过滤的，那么可以显示调用 OmitEmpty/OmitEmptyWhere 方法来执行空条件过滤，如下：

  1. m := g.Model("auth")
  2. m.Where("status", g.Slice{}).Where("uid", 1).OmitEmpty().All()
  3. // SELECT * FROM `auth` WHERE `uid`=1