数据库操作

ORM链式操作使用方式简单灵活，是官方推荐的数据库操作方式。

链式操作

链式操作可以通过数据库对象的db.Table/db.From方法或者事务对象的tx.Table/tx.From方法，基于指定的数据表返回一个链式操作对象*Model，该对象可以执行以下方法（具体方法说明请参考API文档）。

  1. func (md *Model) LeftJoin(joinTable string, on string) *Model
  2. func (md *Model) RightJoin(joinTable string, on string) *Model
  3. func (md *Model) InnerJoin(joinTable string, on string) *Model
  5. func (md *Model) Fields(fields string) *Model
  6. func (md *Model) Limit(start int, limit int) *Model
  7. func (md *Model) Data(data...interface{}) *Model
  8. func (md *Model) Batch(batch int) *Model
  10. func (md *Model) Where(where string, args...interface{}) *Model
  11. func (md *Model) And(where interface{}, args ...interface{}) *Model
  12. func (md *Model) Or(where interface{}, args ...interface{}) *Model
  14. func (md *Model) GroupBy(groupby string) *Model
  15. func (md *Model) OrderBy(orderby string) *Model
  17. func (md *Model) Insert() (sql.Result, error)
  18. func (md *Model) Replace() (sql.Result, error)
  19. func (md *Model) Save() (sql.Result, error)
  20. func (md *Model) Update() (sql.Result, error)
  21. func (md *Model) Delete() (sql.Result, error)
  23. func (md *Model) Select() (Result, error)
  24. func (md *Model) All() (Result, error)
  25. func (md *Model) One() (Record, error)
  26. func (md *Model) Struct(obj interface{}) error
  27. func (md *Model) Value() (Value, error)
  28. func (md *Model) Count() (int, error)

Insert/Replace/Save三个方法的区别：

  1. Insert
    使用insert into语句进行数据库写入，如果写入的数据中存在Primary Key或者Unique Key的情况，返回失败，否则写入一条新数据；
  2. Replace
    使用replace into语句进行数据库写入，如果写入的数据中存在Primary Key或者Unique Key的情况，会删除原有的记录，必定会写入一条新记录；
  3. Save
    使用insert into语句进行数据库写入，如果写入的数据中存在Primary Key或者Unique Key的情况，更新原有数据，否则写入一条新数据；

操作示例

  1. 获取ORM对象

    1.  // 获取默认配置的数据库对象(配置名称为"default")
    2.  db, err := gdb.New()
    3.  // 或者
    4.  db := g.Database()
    5.  // 或者(别名方式)
    6.  db := g.DB()
    8.  // 获取配置分组名称为"user-center"的数据库对象
    9.  db, err := gdb.New("user-center")
    10.  // 或者 
    11.  db := g.Database("user-center")
    12.  // 或者 (别名方式)
    13.  db := g.DB("user-center")
    15.  // 注意不用的时候不需要使用Close方法关闭数据库连接(并且gdb也没有提供Close方法)，
    16.  // 数据库引擎底层采用了链接池设计，当链接不再使用时会自动关闭

  2. 单表/联表查询

    1.  // 查询多条记录并使用Limit分页
    2.  r, err := db.Table("user").Where("u.uid > ?", 1).Limit(0, 10).Select()
    4.  // 查询符合条件的单条记录(第一条)
    5.  r, err := db.Table("user u").LeftJoin("user_detail ud", "u.uid=ud.uid").Fields("u.*,ud.site").Where("u.uid=?", 1).One()
    7.  // 查询指定字段值
    8.  r, err := db.Table("user u").RightJoin("user_detail ud", "u.uid=ud.uid").Fields("ud.site").Where("u.uid=?", 1).Value()
    10.  // 分组及排序
    11.  r, err := db.Table("user u").InnerJoin("user_detail ud", "u.uid=ud.uid").Fields("u.*,ud.city").GroupBy("city").OrderBy("register_time asc").Select()
    13.  // 不使用john的联表查询
    14.  r, err := db.Table("user u,user_detail ud").Where("u.uid=ud.uid").Fields("u.*,ud.city").All()

    其中未使用Fields方法指定查询字段时，默认查询为*。
    支持多种形式的条件参数：

    1.  r, err := db.Table("user").Where("u.uid=1",).One()
    2.  r, err := db.Table("user").Where("u.uid=?", 1).One()
    3.  r, err := db.Table("user").Where(g.Map{"uid" : 1}).One()
    4.  r, err := db.Table("user").Where("uid=？", 1}).And("name=?", "john").One()
    5.  r, err := db.Table("user").Where("uid=？", 1}).Or("name=?", "john").One()
  3. like查询
    1.  // SELECT * FROM `user` WHERE `name` like '%john%'
    2.  r, err := db.Table("user").Where("name like ?", "%john%").Select()
    3.  // SELECT * FROM `user` WHERE `birthday` like '1990-%'
    4.  r, err := db.Table("user").Where("birthday like ?", "1990-%").Select()
  4. count查询
    1.  // SELECT COUNT(*) 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").Field("uid").Where("birthday=?", "1990-10-01").Count()
  5. 链式更新/删除
    1.  // 更新
    2.  r, err := db.Table("user").Data(gdb.Map{"name" : "john2"}).Where("name=?", "john").Update()
    3.  r, err := db.Table("user").Data("name='john3'").Where("name=?", "john2").Update()
    4.  // 删除
    5.  r, err := db.Table("user").Where("uid=?", 10).Delete()
    其中Data是数值方法，用于指定写入/更新/批量写入/批量更新的数值。
    支持多种形式的数值参数：
    1.  r, err := db.Table("user").Data(`name="john"`).Update()
    2.  r, err := db.Table("user").Data("name", "john").Update()
    3.  r, err := db.Table("user").Data(g.Map{"name" : "john"}).Update()
  6. 链式写入/保存
    1.  r, err := db.Table("user").Data(gdb.Map{"name": "john"}).Insert()
    2.  r, err := db.Table("user").Data(g.Map{"uid": 10000, "name": "john"}).Replace()
    3.  r, err := db.Table("user").Data(g.Map{"uid": 10001, "name": "john"}).Save()
    其中，数值方法参数既可以使用gdb.Map，也可以使用g.Map。
  7. 链式批量写入
    1.  r, err := db.Table("user").Data(gdb.List{
    2.      {"name": "john_1"},
    3.      {"name": "john_2"},
    4.      {"name": "john_3"},
    5.      {"name": "john_4"},
    6.  }).Insert()
    可以通过Batch方法指定批量操作中分批写入条数数量：
    1.  r, err := db.Table("user").Data(g.List{
    2.      {"name": "john_1"},
    3.      {"name": "john_2"},
    4.      {"name": "john_3"},
    5.      {"name": "john_4"},
    6.  }).Batch(2).Insert()
    当然，gdb.List类型也可以使用g.List类型。
  8. 链式批量保存
    1.  r, err := db.Table("user").Data(gdb.List{
    2.      {"uid":10000, "name": "john_1"},
    3.      {"uid":10001, "name": "john_2"},
    4.      {"uid":10002, "name": "john_3"},
    5.      {"uid":10003, "name": "john_4"},
    6.  }).Save()

  9. 查询结果转换为Json/Xml

    1.  one, err := db.Table("user").Where("uid=?", 1).One()
    2.  if err != nil {
    3.      panic(err)
    4.  }
    6.  // 使用内置方法转换为json/xml
    7.  fmt.Println(one.ToJson())
    8.  fmt.Println(one.ToXml())
    10.  // 自定义方法方法转换为json/xml
    11.  jsonContent, _ := gparser.VarToJson(one.ToMap())
    12.  fmt.Println(jsonContent)
    13.  xmlContent, _ := gparser.VarToXml(one.ToMap())
    14.  fmt.Println(xmlContent)