ORM链式操作

ORM链式操作

数据库操作

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

链式操作

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

func (md *Model) LeftJoin(joinTable string, on string) *Model
func (md *Model) RightJoin(joinTable string, on string) *Model
func (md *Model) InnerJoin(joinTable string, on string) *Model

func (md *Model) Fields(fields string) *Model
func (md *Model) Limit(start int, limit int) *Model
func (md *Model) Data(data...interface{}) *Model
func (md *Model) Batch(batch int) *Model

func (md *Model) Where(where string, args...interface{}) *Model
func (md *Model) And(where interface{}, args ...interface{}) *Model
func (md *Model) Or(where interface{}, args ...interface{}) *Model

func (md *Model) GroupBy(groupby string) *Model
func (md *Model) OrderBy(orderby string) *Model

func (md *Model) Insert() (sql.Result, error)
func (md *Model) Replace() (sql.Result, error)
func (md *Model) Save() (sql.Result, error)
func (md *Model) Update() (sql.Result, error)
func (md *Model) Delete() (sql.Result, error)

func (md *Model) Select() (Result, error)
func (md *Model) All() (Result, error)
func (md *Model) One() (Record, error)
func (md *Model) Struct(obj interface{}) error
func (md *Model) Value() (Value, error)
func (md *Model) Count() (int, error)

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

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

操作示例

获取ORM对象

 // 获取默认配置的数据库对象(配置名称为"default")
 db, err := gdb.New()
 // 或者
 db := g.Database()
 // 或者(别名方式)
 db := g.DB()

 // 获取配置分组名称为"user-center"的数据库对象
 db, err := gdb.New("user-center")
 // 或者
 db := g.Database("user-center")
 // 或者 (别名方式)
 db := g.DB("user-center")

 // 注意不用的时候不需要使用Close方法关闭数据库连接(并且gdb也没有提供Close方法)，
 // 数据库引擎底层采用了链接池设计，当链接不再使用时会自动关闭

单表/联表查询

 // 查询多条记录并使用Limit分页
 r, err := db.Table("user").Where("u.uid > ?", 1).Limit(0, 10).Select()

 // 查询符合条件的单条记录(第一条)
 r, err := db.Table("user u").LeftJoin("user_detail ud", "u.uid=ud.uid").Fields("u.*,ud.site").Where("u.uid=?", 1).One()

 // 查询指定字段值
 r, err := db.Table("user u").RightJoin("user_detail ud", "u.uid=ud.uid").Fields("ud.site").Where("u.uid=?", 1).Value()

 // 分组及排序
 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()

 // 不使用john的联表查询
 r, err := db.Table("user u,user_detail ud").Where("u.uid=ud.uid").Fields("u.*,ud.city").All()

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

 r, err := db.Table("user").Where("u.uid=1",).One()
 r, err := db.Table("user").Where("u.uid=?", 1).One()
 r, err := db.Table("user").Where(g.Map{"uid" : 1}).One()
 r, err := db.Table("user").Where("uid=？", 1}).And("name=?", "john").One()
 r, err := db.Table("user").Where("uid=？", 1}).Or("name=?", "john").One()

like查询 `` // SELECT * FROMuserWHEREnamelike '%john%' r, err := db.Table("user").Where("name like ?", "%john%").Select() // SELECT * FROMuserWHEREbirthday` like '1990-%' r, err := db.Table("user").Where("birthday like ?", "1990-%").Select()

  4. **count查询** ```
 // SELECT COUNT(*) FROM `user` WHERE `birthday`='1990-10-01'
 r, err := db.Table("user").Where("birthday=?", "1990-10-01").Count()
 // SELECT COUNT(`uid`) FROM `user` WHERE `birthday`='1990-10-01'
 r, err := db.Table("user").Field("uid").Where("birthday=?", "1990-10-01").Count()

链式更新/删除 // 更新 r, err := db.Table("user").Data(gdb.Map{"name" : "john2"}).Where("name=?", "john").Update() r, err := db.Table("user").Data("name='john3'").Where("name=?", "john2").Update() // 删除 r, err := db.Table("user").Where("uid=?", 10).Delete() 其中Data是数值方法，用于指定写入/更新/批量写入/批量更新的数值。支持多种形式的数值参数： `` r, err := db.Table("user").Data(name="john"`).Update() r, err := db.Table("user").Data("name", "john").Update() r, err := db.Table("user").Data(g.Map{"name" : "john"}).Update()

  6. **链式写入/保存** ```
 r, err := db.Table("user").Data(gdb.Map{"name": "john"}).Insert()
 r, err := db.Table("user").Data(g.Map{"uid": 10000, "name": "john"}).Replace()
 r, err := db.Table("user").Data(g.Map{"uid": 10001, "name": "john"}).Save()
``` 其中，数值方法参数既可以使用gdb.Map，也可以使用g.Map。
  7. **链式批量写入** ```
 r, err := db.Table("user").Data(gdb.List{
     {"name": "john_1"},
     {"name": "john_2"},
     {"name": "john_3"},
     {"name": "john_4"},
 }).Insert()
``` 可以通过`Batch`方法指定批量操作中分批写入条数数量： ```
 r, err := db.Table("user").Data(g.List{
     {"name": "john_1"},
     {"name": "john_2"},
     {"name": "john_3"},
     {"name": "john_4"},
 }).Batch(2).Insert()
``` 当然，gdb.List类型也可以使用g.List类型。
  8. **链式批量保存** ```
 r, err := db.Table("user").Data(gdb.List{
     {"uid":10000, "name": "john_1"},
     {"uid":10001, "name": "john_2"},
     {"uid":10002, "name": "john_3"},
     {"uid":10003, "name": "john_4"},
 }).Save()

查询结果转换为Json/Xml

 one, err := db.Table("user").Where("uid=?", 1).One()
 if err != nil {
     panic(err)
 }

 // 使用内置方法转换为json/xml
 fmt.Println(one.ToJson())
 fmt.Println(one.ToXml())

 // 自定义方法方法转换为json/xml
 jsonContent, _ := gparser.VarToJson(one.ToMap())
 fmt.Println(jsonContent)
 xmlContent, _ := gparser.VarToXml(one.ToMap())
 fmt.Println(xmlContent)