Insert/InsertIgnore/Replace/Save

这几个链式操作方法用于数据的写入,并且支持自动的单条或者批量的数据写入,区别如下:

  1. Insert

    使用INSERT INTO语句进行数据库写入,如果写入的数据中存在主键或者唯一索引时,返回失败,否则写入一条新数据;

  2. InsertIgnore

    使用INSERT IGNORE INTO语句进行数据库写入,如果写入的数据中存在主键或者唯一索引时,忽略错误继续执行写入;

  3. Replace

    使用REPLACE INTO语句进行数据库写入,如果写入的数据中存在主键或者唯一索引时,会删除原有的记录,必定会写入一条新记录;

  4. Save

    使用INSERT INTO语句进行数据库写入,如果写入的数据中存在主键或者唯一索引时,更新原有数据,否则写入一条新数据;

在部分数据库类型中,并不支持Replace/Save方法,具体请参考数据库类型介绍章节。

这三个方法往往需要结合Data方法使用,该方法用于传递数据参数,用于数据写入/更新等写操作,支持的参数为string/map/slice/struct/*struct。例如,在进行Insert操作时,开发者可以传递任意的map类型,如: map[string]string/map[string]interface{}/map[interface{}]interface{}等等,也可以传递任意的struct/*struct/[]struct/[]*struct类型。此外,这三个方法也支持直接的data参数输入,该参数Data方法参数一致。

使用示例

示例1,基本使用

数据写入/保存方法往往需要结合Data方法使用:

  1. // INSERT INTO `user`(`name`) VALUES('john')
  2. r, err := db.Table("user").Data(g.Map{"name": "john"}).Insert()
  3. // INSERT IGNORE INTO `user`(`uid`,`name`) VALUES(10000,'john')
  4. r, err := db.Table("user").Data(g.Map{"uid": 10000, "name": "john"}).InsertIgnore()
  5. // REPLACE INTO `user`(`uid`,`name`) VALUES(10000,'john')
  6. r, err := db.Table("user").Data(g.Map{"uid": 10000, "name": "john"}).Replace()
  7. // INSERT INTO `user`(`uid`,`name`) VALUES(10001,'john') ON DUPLICATE KEY UPDATE `uid`=VALUES(`uid`),`name`=VALUES(`name`)
  8. r, err := db.Table("user").Data(g.Map{"uid": 10001, "name": "john"}).Save()

也可以不使用Data方法,而给写入/保存方法直接传递数据参数:

  1. r, err := db.Table("user").Insert(g.Map{"name": "john"})
  2. r, err := db.Table("user").Replace(g.Map{"uid": 10000, "name": "john"})
  3. r, err := db.Table("user").Save(g.Map{"uid": 10001, "name": "john"})

数据参数也常用struct类型,例如当表字段为uid/name/site时:

  1. type User struct {
  2. Uid int `orm:"uid"`
  3. Name string `orm:"name"`
  4. Site string `orm:"site"`
  5. }
  6. user := &User{
  7. Uid: 1,
  8. Name: "john",
  9. Site: "https://goframe.org",
  10. }
  11. // INSERT INTO `user`(`uid`,`name`,`site`) VALUES(1,'john','https://goframe.org')
  12. r, err := g.DB().Table("user").Data(user).Insert()

示例2,数据批量写入

  1. // INSERT INTO `user`(`name`) VALUES('john_1'),('john_2'),('john_3')
  2. r, err := db.Table("user").Data(g.List{
  3. {"name": "john_1"},
  4. {"name": "john_2"},
  5. {"name": "john_3"},
  6. }).Insert()

可以通过Batch方法指定批量操作中分批写入条数数量(默认是10),以下示例将会被拆分为两条写入请求:

  1. // INSERT INTO `user`(`name`) VALUES('john_1'),('john_2')
  2. // INSERT INTO `user`(`name`) VALUES('john_3')
  3. r, err := db.Table("user").Data(g.List{
  4. {"name": "john_1"},
  5. {"name": "john_2"},
  6. {"name": "john_3"},
  7. }).Batch(2).Insert()

示例3,数据批量保存

批量保存操作与单条保存操作原理是一样的,当写入的数据中存在主键或者唯一索引时将会更新原有记录值,否则新写入一条记录。

  1. // INSERT INTO `user`(`uid`,`name`) VALUES(10000,'john_1'),(10001,'john_2'),(10002,'john_3')
  2. // ON DUPLICATE KEY UPDATE `uid`=VALUES(`uid`),`name`=VALUES(`name`)
  3. r, err := db.Table("user").Data(g.List{
  4. {"uid":10000, "name": "john_1"},
  5. {"uid":10001, "name": "john_2"},
  6. {"uid":10002, "name": "john_3"},
  7. }).Save()

RawSQL语句嵌入

gdb.Raw是字符串类型,该类型的参数将会直接作为SQL片段嵌入到提交到底层的SQL语句中,不会被自动转换为字符串参数类型、也不会被当做预处理参数。例如:

  1. // INSERT INTO `user`(`id`,`passport`,`password`,`nickname`,`create_time`) VALUES('id+2','john','123456','now()')
  2. db.Model("user").Data(g.Map{
  3. "id": "id+2",
  4. "passport": "john",
  5. "password": "123456",
  6. "nickname": "JohnGuo",
  7. "create_time": "now()",
  8. }).Insert()
  9. // 执行报错:Error Code: 1136. Column count doesn't match value count at row 1

使用gdb.Raw改造后:

  1. // INSERT INTO `user`(`id`,`passport`,`password`,`nickname`,`create_time`) VALUES(id+2,'john','123456',now())
  2. db.Model("user").Data(g.Map{
  3. "id": gdb.Raw("id+2"),
  4. "passport": "john",
  5. "password": "123456",
  6. "nickname": "JohnGuo",
  7. "create_time": gdb.Raw("now()"),
  8. }).Insert()