golang -gorm 增删改查操作,事务操作-EW帮帮网

增删改查

1. 插入数据


// api
func SaveUser(ctx *gin.Context) {
	result := &common.Result{}
	user := &dao.User{}
	err := ctx.ShouldBindJSON(&user)
	if err != nil {
		ctx.JSON(http.StatusOK, result.Fail(400, "请使用json数据格式传值"))
		return
	}

	// 调用验证函数
	if err := validate.ValidateUser(user); err != nil {
		ctx.JSON(http.StatusBadRequest, result.Fail(400, err.Error()))
		return
	}
	user.CreateTime = time.Now().Unix()

	_, err = dao.SaveUser(user)
	if err != nil {
		ctx.JSON(http.StatusOK, result.Fail(400, err.Error()))
		return
	}

	ctx.JSON(http.StatusOK, result.Success("添加成功"))
}

// dao
func SaveUser(user *User) (bool, error) {

	var count int64
	err := DB.Model(&User{}).Where("username = ?", user.Username).Count(&count).Error
	if err != nil {
		return false, err
	}
	if count > 0 {
		return false, fmt.Errorf("该用户(%s)已存在", user.Username)
	}

	tx := DB.Create(user)

	if tx.Error != nil {
		log.Println("insert fail : ", tx.Error)
		return false, tx.Error
	}
	return true, nil
}

1.1 用指定的字段创建：

func SelectUser() {
	var user User
	user.Username = "test"
	user.Password = "123456"
	DB.Model(&User{}).Select("username", "password").Create(&user)
}

在这里插入图片描述

1.2 忽略字段

func SelectUser() {
	var user User
	user.Username = "test"
	user.Password = "123456"
	user.CreateTime = time.Now().UnixMilli()
	DB.Model(&User{}).Omit("username").Create(&user)
}



//结果：
 INSERT INTO `users` (`password`,`createtime`) VALUES ('123456',1752196334754)

1.3 批量插入：

func SelectUser() {
	var user []User
	hashedPassword := fmt.Sprintf("%x", md5.Sum([]byte("123456")))
	for i := 0; i < 10; i++ {

		user = append(user, User{
			Username:   fmt.Sprintf("test_%d", i+1),
			Password:   hashedPassword,
			CreateTime: time.Now().UnixMilli(),
		})
	}
	DB.Model(&User{}).Create(&user)
}



[8.110ms] [rows:10] INSERT INTO `users` (`username`,`password`,`createtime`) VALUES ('test_1','e10adc3949ba59abbe56e057f20f883e',1752197175608),('test_2','e10adc3949ba59abbe56e057f20f883e',1752197175608),('test_3','e10adc3949ba59abbe56e057f20f883e',1752197175608),('test_4','e10adc3949ba59abbe56e057f20f883e',1752197175608),('test_5','e10adc3949ba59abbe56e057f20f883e',1752197175608),('test_6','e10adc3949ba59abbe56e057f20f883e',1752197175608),('test_7','e10adc3949ba59abbe56e057f20f883e',1752197175608),('test_8','e10adc3949ba59abbe56e057f20f883e',1752197175608),('test_9','e10adc3949ba59abbe56e057f20f883e',1752197175608),('test_10','e10adc3949ba59abbe56e057f20f883e',1752197175608)

使用 CreateInBatches 分批创建时，你可以指定每批的数量，例如：

var users = []User{{Username: "jinzhu_1"}, ...., {Username: "jinzhu_10000"}}

// 数量为 100
db.CreateInBatches(users, 100)

1.4 使用map创建：

db.Model(&User{}).Create(map[string]interface{}{
  "Name": "xxp", "Age": 18,
})

// batch insert from `[]map[string]interface{}{}`
db.Model(&User{}).Create([]map[string]interface{}{
  {"Name": "damao", "Age": 18},
  {"Name": "xiaomao", "Age": 20},
})

map创建注意，主键不会被填充。

1.5 sql表达式：

DB.Model(&User{}).Create(map[string]interface{}{
		"username": "jinzhu",
		"password": clause.Expr{SQL: "md5(?)", Vars: []interface{}{"123456"}},
	})

1.6 使用原生sql语句：

Exec 通常是用户操作不返回的例如：insert，update，


	db.Exec("insert into users (username,password,createtime) values (?,?,?)", user.Username, user.Password, user.CreateTime)

Exec 通常是用户操作不返回的例如：insert，update，

func SelectUser() {
	var user []User
	tx := DB.Raw("select * from users where id = ?", 1).Scan(&user).Error
	if tx != nil {
		log.Println("select fail : ", tx)
		return
	}
	fmt.Println(user)
}

在这里插入图片描述

2. 更新数据

在创建一个表

CREATE TABLE `goods` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '商品id',
  `title` varchar(100) NOT NULL COMMENT '商品名',
  `price` decimal(10, 2) NULL DEFAULT 0.00 COMMENT '商品价格',
  `stock` int(11) DEFAULT '0' COMMENT '商品库存',
  `type` int(11) DEFAULT '0' COMMENT '商品类型',
  `create_time` datetime NOT NULL COMMENT '商品创建时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

package dao

import "time"

type Goods struct {
	Id         int
	Title      string
	Price      float64
	Stock      int
	Type       int
	CreateTime time.Time
}

func (v Goods) TableName() string {
	return "goods"
}

func SaveGoods(goods Goods) {
	DB.Create(&goods)
}

package dao

import (
	"testing"
	"time"
)

func TestSaveGoods(t *testing.T) {
	goods := Goods{
		Title:      "毛巾",
		Price:      25,
		Stock:      100,
		Type:       0,
		CreateTime: time.Now(),
	}
	SaveGoods(goods)
}

2.1 保存数据

	goods := Goods{}
	DB.Where("id = ?", 1).Take(&goods)

	goods.Price = 100
	//UPDATE `goods` SET `title`='毛巾',`price`=100.000000,`stock`=100,`type`=0,`create_time  `='2022-11-25 13:03:48' WHERE `id` = 1
	DB.Save(&goods)

2.2 更新单个列

	goods := Goods{}
	DB.Where("id = ?", 2).Take(&goods)
	DB.Model(&goods).Update("title", "hello")

2.3 更新多列

    goods := Goods{}
	DB.Where("id = ?", 2).Take(&goods)
    //更新非零值的字段  也可以使用map
	DB.Model(&goods).Updates(Goods{
		Title: "hello",
		Stock: 200,
	})

2.4 更新选定的字段

goods := Goods{}
	DB.Where("id = ?", 2).Take(&goods)
	DB.Model(&goods).Select("title").Updates(Goods{
		Title: "hello",
		Stock: 200,
	})

排除：

goods := Goods{}
	DB.Where("id = ?", 2).Take(&goods)
	DB.Model(&goods).Omit("title").Updates(Goods{
		Title: "hello",
		Stock: 200,
	})

也可以组合使用

Select("*").Omit("title")

gorm更新必须带条件进行更新，否则会返回错误gorm.ErrMissingWhereClause，或者启用 AllowGlobalUpdate 模式

db.Session(&gorm.Session{AllowGlobalUpdate: true}).Model(&User{}).Update("name", "jinzhu")

2.5 表达式

db.Model(&goods).Update("stock", gorm.Expr("stock + 1"))
db.Model(&goods).Update(map[string]interface{}{"stock": gorm.Expr("stock + 1")})

2.6 子查询更新

  goods := Goods{}
	DB.Where("id = ?", 2).Take(&goods)
	DB.Model(&goods).Update("title", DB.Model(&User{}).Select("username").Where("id=?", 2))

3. 删除数据

	goods := Goods{}
	DB.Where("id = ?", 2).Take(&goods)
	DB.Delete(&goods)

//根据主键删除
DB.Delete(&Goods{}, 1)

同样的道理，不带条件不能进行删除，必须加一些条件，或者使用原生 SQL，或者启用 AllowGlobalUpdate 模式

db.Session(&gorm.Session{AllowGlobalUpdate: true}).Delete(&User{})
// DELETE FROM users

4. 查询数据

4.1 查询函数

Take：查询一条记录
```
db.Take(&goods)
```
First: 根据主键正序排序后，查询第一条数据
```
db.First(&goods)
```
Last：根据主键倒序排序后，查询最后一条记录
```
db.Last(&goods)
```
Find：查询多条记录
```
db.Find(&goods)
```

Pluck：查询一列值

var titles []string
db.Model(&Goods{}).Pluck("title", &titles)

当 First、Last、Take 方法找不到记录时，GORM 会返回 ErrRecordNotFound 错误，可以通过对比gorm.ErrRecordNotFound进行判断，或者使用Find和Limit的组合进行查询。

db.Limit(1).Find(&user)

4.2 where

通过db.Where函数设置条件

函数说明：
db.Where(query interface{}, args ...interface{})

参数说明:

参数名	说明
query	sql语句的where子句, where子句中使用问号(?)代替参数值，则表示通过args参数绑定参数
args	where子句绑定的参数，可以绑定多个参数

比如：

db.Where("id in (?)", []int{1,2,5,6}).Take(&goods)

4.3 select

设置select子句, 指定返回的字段

var goods Goods
DB.Select("id", "title").Find(&goods)

也可以写聚合函数

var total int
DB.Model(&Goods{}).Select("count(*) as total").Pluck("total", &total)
fmt.Println(total)

4.4 order

排序

var goods []Goods
	DB.Order("id desc").Find(&goods)

4.5 分页

通过limit和Offset实现

var goods []Goods
DB.Order("create_time desc").Limit(10).Offset(10).Find(&goods)

4.6 count

返回查询匹配的行数

var total int64 = 0
DB.Model(Goods{}).Count(&total)
fmt.Println(total)

4.7 分组

//统计每个商品分类下面有多少个商品
//定一个Result结构体类型，用来保存查询结果
type Result struct {
    Type  int
    Total int
}
var results []Result
//等价于: SELECT type, count(*) as  total FROM `goods` GROUP BY type HAVING (total > 0)
db.Model(Goods{}).Select("type, count(*) as  total").Group("type").Having("total > 0").Scan(&results)

//scan类似Find都是用于执行查询语句，然后把查询结果赋值给结构体变量，区别在于scan不会从传递进来的结构体变量提取表名.
//这里因为我们重新定义了一个结构体用于保存结果，但是这个结构体并没有绑定goods表，所以这里只能使用scan查询函数。

Group函数必须搭配Select函数一起使用

4.8 直接执行sql语句

sql := "SELECT type, count(*) as  total FROM `goods` where create_time > ? GROUP BY type HAVING (total > 0)"
//因为sql语句使用了一个问号(?)作为绑定参数, 所以需要传递一个绑定参数(Raw第二个参数).
//Raw函数支持绑定多个参数
db.Raw(sql, "2022-11-06 00:00:00").Scan(&results)
fmt.Println(results)

事务和Hook

1. 会话Session

为了避免共用db导致的一些问题，gorm提供了会话模式，通过新建session的形式，将db的操作分离，互不影响。

创建session的时候，有一些配置：

// Session 配置
type Session struct {
  DryRun                   bool   //生成 SQL 但不执行
  PrepareStmt              bool   //预编译模式
  NewDB                    bool  //新db 不带之前的条件
  Initialized              bool  //初始化新的db
  SkipHooks                bool  //跳过钩子
  SkipDefaultTransaction   bool  //禁用默认事务
  DisableNestedTransaction bool  //禁用嵌套事务
  AllowGlobalUpdate        bool  //允许不带条件的更新
  FullSaveAssociations     bool  //允许更新关联数据
  QueryFields              bool  //select（字段）
  Context                  context.Context
  Logger                   logger.Interface
  NowFunc                  func() time.Time //允许改变 GORM 获取当前时间的实现
  CreateBatchSize          int  
}

比如说可以禁用默认的事务，从而提供性能，官方说大致能提升30%左右：

// 持续会话模式
tx := db.Session(&Session{SkipDefaultTransaction: true})
tx.First(&user, 1)
tx.Find(&users)
tx.Model(&user).Update("Age", 18)

比如使用PreparedStmt 在执行任何 SQL 时都会创建一个 prepared statement 并将其缓存，以提高后续的效率

// 会话模式
tx := db.Session(&Session{PrepareStmt: true})
tx.First(&user, 1)
tx.Find(&users)
tx.Model(&user).Update("Age", 18)

// returns prepared statements manager
stmtManger, ok := tx.ConnPool.(*PreparedStmtDB)

// 关闭 *当前会话* 的预编译模式
stmtManger.Close()

// 为 *当前会话* 预编译 SQL
stmtManger.PreparedSQL // => []string{}

// 为当前数据库连接池的（所有会话）开启预编译模式
stmtManger.Stmts // map[string]*sql.Stmt

for sql, stmt := range stmtManger.Stmts {
  sql  // 预编译 SQL
  stmt // 预编译模式
  stmt.Close() // 关闭预编译模式
}

还有，gorm的db默认是协程安全的，如果使用初始化参数，则db不在协程安全：

tx := db.Session(&gorm.Session{Initialized: true})

比如context：

timeoutCtx, _ := context.WithTimeout(context.Background(), time.Second)
tx := db.Session(&Session{Context: timeoutCtx})

tx.First(&user) // 带有 context timeoutCtx 的查询操作
tx.Model(&user).Update("role", "admin") // 带有 context timeoutCtx 的更新操作

2. 事务

2.1 自动事务

db.Transaction(func(tx *gorm.DB) error {
  // 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'）
  if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
    // 返回任何错误都会回滚事务
    return err
  }
  if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
    return err
  }
  // 返回 nil 提交事务
  return nil
})

2.2 嵌套事务

GORM 支持嵌套事务，您可以回滚较大事务内执行的一部分操作，例如：

db.Transaction(func(tx *gorm.DB) error {
  tx.Create(&user1)

  tx.Transaction(func(tx2 *gorm.DB) error {
    tx2.Create(&user2)
    return errors.New("rollback user2") // Rollback user2
  })

  tx.Transaction(func(tx2 *gorm.DB) error {
    tx2.Create(&user3)
    return nil
  })

  return nil
})

// Commit user1, user3

2.3 手动事务

// 开始事务
tx := db.Begin()

// 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'）
tx.Create(...)

// ...

// 遇到错误时回滚事务
tx.Rollback()

// 否则，提交事务
tx.Commit()

比如

// 开启事务
tx := db.Begin()

//在事务中执行数据库操作，使用的是tx变量，不是db。
//库存减一
//等价于: UPDATE `goods` SET `stock` = stock - 1  WHERE `goods`.`id` = '2' and stock > 0
//RowsAffected用于返回sql执行后影响的行数
rowsAffected := tx.Model(&goods).Where("stock > 0").Update("stock", gorm.Expr("stock - 1")).RowsAffected
if rowsAffected == 0 {
    //如果更新库存操作，返回影响行数为0，说明没有库存了，结束下单流程
    //这里回滚作用不大，因为前面没成功执行什么数据库更新操作，也没什么数据需要回滚。
    //这里就是举个例子，事务中可以执行多个sql语句，错误了可以回滚事务
    tx.Rollback()
    return
}
err := tx.Create(保存订单).Error

//保存订单失败，则回滚事务
if err != nil {
    tx.Rollback()
} else {
    tx.Commit()
}

2.4 保存点

GORM 提供了 SavePoint、Rollbackto 方法，来提供保存点以及回滚至保存点功能，例如：

tx := db.Begin()
tx.Create(&user1)

tx.SavePoint("sp1")
tx.Create(&user2)
tx.RollbackTo("sp1") // Rollback user2

tx.Commit() // Commit user1

3. Hook

Hook 是在创建、查询、更新、删除等操作之前、之后调用的函数。

如果您已经为模型定义了指定的方法，它会在创建、更新、查询、删除时自动被调用。如果任何回调返回错误，GORM 将停止后续的操作并回滚事务。

钩子方法的函数签名应该是 func(*gorm.DB) error

3.1 创建

创建时可用的 hook

// 开始事务
BeforeSave
BeforeCreate
// 关联前的 save
// 插入记录至 db
// 关联后的 save
AfterCreate
AfterSave
// 提交或回滚事务

func (u *User) BeforeCreate(tx *gorm.DB) (err error) {
  u.UUID = uuid.New()

  if !u.IsValid() {
    err = errors.New("can't save invalid data")
  }
  return
}

func (u *User) AfterCreate(tx *gorm.DB) (err error) {
  if u.ID == 1 {
    tx.Model(u).Update("role", "admin")
  }
  return
}

在 GORM 中保存、删除操作会默认运行在事务上，因此在事务完成之前该事务中所作的更改是不可见的，如果您的钩子返回了任何错误，则修改将被回滚。

func (u *User) AfterCreate(tx *gorm.DB) (err error) {
  if !u.IsValid() {
    return errors.New("rollback invalid user")
  }
  return nil
}

3.2 更新

更新时可用的 hook

// 开始事务
BeforeSave
BeforeUpdate
// 关联前的 save
// 更新 db
// 关联后的 save
AfterUpdate
AfterSave
// 提交或回滚事务

代码示例：

func (u *User) BeforeUpdate(tx *gorm.DB) (err error) {
  if u.readonly() {
    err = errors.New("read only user")
  }
  return
}

// 在同一个事务中更新数据
func (u *User) AfterUpdate(tx *gorm.DB) (err error) {
  if u.Confirmed {
    tx.Model(&Address{}).Where("user_id = ?", u.ID).Update("verfied", true)
  }
  return
}

3.3 删除

删除时可用的 hook

// 开始事务
BeforeDelete
// 删除 db 中的数据
AfterDelete
// 提交或回滚事务

代码示例：

// 在同一个事务中更新数据
func (u *User) AfterDelete(tx *gorm.DB) (err error) {
  if u.Confirmed {
    tx.Model(&Address{}).Where("user_id = ?", u.ID).Update("invalid", false)
  }
  return
}

3.4 查询

查询时可用的 hook

// 从 db 中加载数据
// Preloading (eager loading)
AfterFind

代码示例：

func (u *User) AfterFind(tx *gorm.DB) (err error) {
  if u.MemberShip == "" {
    u.MemberShip = "user"
  }
  return
}

高级查询

1. scope

作用域允许你复用通用的逻辑，这种共享逻辑需要定义为类型func(*gorm.DB) *gorm.DB。

例子：

func Paginate(r *http.Request) func(db *gorm.DB) *gorm.DB {
  return func (db *gorm.DB) *gorm.DB {
    q := r.URL.Query()
    page, _ := strconv.Atoi(q.Get("page"))
    if page == 0 {
      page = 1
    }

    pageSize, _ := strconv.Atoi(q.Get("page_size"))
    switch {
    case pageSize > 100:
      pageSize = 100
    case pageSize <= 0:
      pageSize = 10
    }

    offset := (page - 1) * pageSize
    return db.Offset(offset).Limit(pageSize)
  }
}

db.Scopes(Paginate(r)).Find(&users)
db.Scopes(Paginate(r)).Find(&articles)

2. 智能选择字段

type User struct {
  ID     uint
  Name   string
  Age    int
  Gender string
  // 假设后面还有几百个字段...
}

type APIUser struct {
  ID   uint
  Name string
}

// 查询时会自动选择 `id`, `name` 字段
db.Model(&User{}).Limit(10).Find(&APIUser{})
// SELECT `id`, `name` FROM `users` LIMIT 10

3. 子查询

db.Where("amount > (?)", db.Table("orders").Select("AVG(amount)")).Find(&orders)
// SELECT * FROM "orders" WHERE amount > (SELECT AVG(amount) FROM "orders");

from子查询

db.Table("(?) as u", db.Model(&User{}).Select("name", "age")).Where("age = ?", 18).Find(&User{})
// SELECT * FROM (SELECT `name`,`age` FROM `users`) as u WHERE `age` = 18

subQuery1 := db.Model(&User{}).Select("name")
subQuery2 := db.Model(&Pet{}).Select("name")
db.Table("(?) as u, (?) as p", subQuery1, subQuery2).Find(&User{})

4. 关联操作

CREATE TABLE `gorm`.`user_profiles`  (
  `id` int(20) NOT NULL AUTO_INCREMENT,
  `sex` tinyint(4) NULL DEFAULT NULL,
  `age` int(10) NULL DEFAULT NULL,
  `user_id` int(20) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4;

比如有一个用户属性表，查询用户的时候需要将其的性别和年龄查询出来：

type UserProfile struct {
	ID     int64
	UserId int64
	Sex    int
	Age    int

}

func (u UserProfile) TableName() string {
	return "user_profiles"
}

type User struct {
	ID          int64
	Username    string `gorm:"column:username"`
	Password    string `gorm:"column:password"`
	CreateTime  int64  `gorm:"column:createtime"`
	UserProfile UserProfile
}

保存User

var user = User{
		Username:   "ms",
		Password:   "ms",
		CreateTime: time.Now().UnixMilli(),
		UserProfile: UserProfile{
			Sex: 0,
			Age: 20,
		},
	}
	DB.Save(&user)

会产生两条sql，users表和user_profiles表都有数据

这是因为默认的外键是结构体名字+下划线+id，即UserId或者表字段是user_id

如果将user_profiles表中的user_id改为other_id就会失败。

type User struct {
	ID          int64
	Username    string      `gorm:"column:username"`
	Password    string      `gorm:"column:password"`
	CreateTime  int64       `gorm:"column:createtime"`
	UserProfile UserProfile `gorm:"foreignKey:OtherId"`
}

只要给UserProfile添加上相应的tag即可。

关联标签

标签	描述
foreignKey	指定当前模型的列作为连接表的外键
references	指定引用表的列名，其将被映射为连接表外键
polymorphic	指定多态类型，比如模型名
polymorphicValue	指定多态值、默认表名
many2many	指定连接表表名
joinForeignKey	指定连接表的外键列名，其将被映射到当前表
joinReferences	指定连接表的外键列名，其将被映射到引用表
constraint	关系约束，例如：`OnUpdate`、`OnDelete`

4.1 查询

	var users []User
	err := DB.Preload("UserProfile").Find(&users).Error
	fmt.Println(err)
	fmt.Println(users)

Preload预加载，直接加载关联关系

也可以使用joins进行加载关联数据：

    var users []User
	err := DB.Joins("UserProfile").Find(&users).Error
	fmt.Println(err)
	fmt.Println(users)

从sql中能看的出来，使用了left join。

如果不想要User的数据，只想要关联表的数据，可以这么做：

   var user User
	DB.Where("id=?", 25).Take(&user)
	var userProfile UserProfile
	err := DB.Model(&user).Association("UserProfile").Find(&userProfile)
	fmt.Println(err)
	fmt.Println(userProfile)

golang -gorm 增删改查操作,事务操作

增删改查

1. 插入数据

1.1 用指定的字段创建：

1.2 忽略字段

1.3 批量插入：

1.4 使用map创建：

1.5 sql表达式：

1.6 使用原生sql语句：

Exec 通常是用户操作不返回的 例如：insert，update，

Exec 通常是用户操作不返回的 例如：insert，update，

2. 更新数据

2.1 保存数据

2.2 更新单个列

2.3 更新多列

2.4 更新选定的字段

2.5 表达式

2.6 子查询更新

3. 删除数据

4. 查询数据

4.1 查询函数

4.2 where

4.3 select

4.4 order

4.5 分页

4.6 count

4.7 分组

4.8 直接执行sql语句

事务和Hook

1. 会话Session

2. 事务

2.1 自动事务

2.2 嵌套事务

2.3 手动事务

2.4 保存点

3. Hook

3.1 创建

3.2 更新

3.3 删除

3.4 查询

高级查询

1. scope

2. 智能选择字段

3. 子查询

4. 关联操作

4.1 查询

网站公告

今日签到

热门文章

最新发布

Exec 通常是用户操作不返回的例如：insert，update，

Exec 通常是用户操作不返回的例如：insert，update，