【Go学习】04-4-Gorm框架-增删改查事务钩子

ops/2025/3/16 6:43:53/

【Go学习】04-4-Gorm框架-增删改查

  • 增删改查
    • 插入数据
      • 用指定的字段创建
      • 忽略字段
      • 批量插入
      • map创建
      • sql表达式
      • 使用原生sql语句
    • 更新数据
      • 保存数据
      • 更新单个列
      • 更新多列
      • 更新选定的字段
      • 表达式
      • 子查询更新
    • 删除数据
    • 查询数据
      • 查询函数
      • where
      • select
      • order
      • 分页
      • count
      • 分组
      • 直接执行sql语句
  • 事务和Hook
    • 会话Session
    • 事务
      • 自动事务
      • 嵌套事务
      • 手动事务
      • 保存点
    • Hook
      • 创建
      • 更新
      • 删除
      • 查询
  • 高级查询
    • scope
    • 智能选择字段
    • 子查询
    • 关联操作
      • 查询


增删改查

插入数据

go">user := User{Username:"zhangsan",Password:"123456",CreateTime:time.Now().Unix(),
}
db.Create(&user)user.ID             // 返回插入数据的主键
result.Error        // 返回 error
result.RowsAffected // 返回插入记录的条数

用指定的字段创建

go">db.Select("username","password").Create(&user)

忽略字段

go">db.Omit("username").Create(&user)

批量插入

go">var users = []User{{Username: "jinzhu1"}, {Username: "jinzhu2"}, {Username: "jinzhu3"}}
db.Create(&users)for _, user := range users {user.ID // 1,2,3
}

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

go">var users = []User{{Username: "jinzhu_1"}, ...., {Username: "jinzhu_10000"}}
// 数量为 100
db.CreateInBatches(users, 100)

map创建

go">db.Model(&User{}).Create(map[string]interface{}{"Name": "jinzhu", "Age": 18,
})// batch insert from `[]map[string]interface{}{}`
db.Model(&User{}).Create([]map[string]interface{}{{"Name": "jinzhu_1", "Age": 18},{"Name": "jinzhu_2", "Age": 20},
})

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

sql表达式

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

使用原生sql语句

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

更新数据

再创建一个表

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;

dao层

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

保存数据

go">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)

更新单个列

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

更新多列

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

更新选定的字段

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

排除:

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

也可以组合使用

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

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

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

表达式

go">db.Model(&goods).Update("stock", gorm.Expr("stock + 1"))
db.Model(&goods).Update(map[string]interface{}{"stock": gorm.Expr("stock + 1")})
  • gorm.Expr("stock + 1") 使 GORM 直接在数据库中执行 stock = stock + 1,而不是在 Go 代码中先计算 stock+1 再传给数据库

子查询更新

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

删除数据

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

根据主键删除

go">DB.Delete(&Goods{}, 1)

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

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

查询数据

查询函数

  • Take:查询一条记录

    go">db.Take(&goods)
    
  • First: 根据主键正序排序后,查询第一条数据

    go">db.First(&goods)
    
  • Last:根据主键倒序排序后,查询最后一条记录

    go">db.Last(&goods)
    
  • Find:查询多条记录

    go">db.Find(&goods)
    
  • Pluck:查询一列值

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

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

go">db.Limit(1).Find(&user)

where

通过db.Where函数设置条件

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

参数说明:

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

比如:

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

select

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

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

也可以写聚合函数

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

order

排序

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

分页

通过limit和Offset实现

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

count

返回查询匹配的行数

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

分组

go">//统计每个商品分类下面有多少个商品
//定一个Result结构体类型,用来保存查询结果
type Result struct {Type  intTotal 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函数一起使用

直接执行sql语句

go">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

会话Session

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

创建session的时候,有一些配置:

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

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

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

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

go">// 会话模式
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.Stmtfor sql, stmt := range stmtManger.Stmts {sql  // 预编译 SQLstmt // 预编译模式stmt.Close() // 关闭预编译模式
}

还有,gorm的db默认是协程安全的,如果使用初始化参数,则db不再协程安全:

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

比如context:

go">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 的更新操作

事务

自动事务

go">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
})

嵌套事务

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

go">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

手动事务

go">// 开始事务
tx := db.Begin()// 在事务中执行一些 db 操作(从这里开始,您应该使用 'tx' 而不是 'db')
tx.Create(...)// ...// 遇到错误时回滚事务
tx.Rollback()// 否则,提交事务
tx.Commit()

比如

go">// 开启事务
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()
}

保存点

GORM 提供了 SavePointRollbackto 方法,来提供保存点以及回滚至保存点功能,例如:

go">tx := db.Begin()
tx.Create(&user1)tx.SavePoint("sp1")
tx.Create(&user2)
tx.RollbackTo("sp1") // Rollback user2tx.Commit() // Commit user1

Hook

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

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

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

创建

创建时可用的 hook

go">// 开始事务
BeforeSave
BeforeCreate
// 关联前的 save
// 插入记录至 db
// 关联后的 save
AfterCreate
AfterSave
// 提交或回滚事务
go">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 中保存、删除操作会默认运行在事务上, 因此在事务完成之前该事务中所作的更改是不可见的,如果您的钩子返回了任何错误,则修改将被回滚。

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

更新

更新时可用的 hook

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

代码示例:

go">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
}

删除

删除时可用的 hook

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

代码示例:

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

查询

查询时可用的 hook

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

代码示例:

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

高级查询

scope

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

例子:

分页查询就可以进行复用

go">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 = 100case pageSize <= 0:pageSize = 10}offset := (page - 1) * pageSizereturn db.Offset(offset).Limit(pageSize)}
}db.Scopes(Paginate(r)).Find(&users)
db.Scopes(Paginate(r)).Find(&articles)

智能选择字段

相当于对responce进行部分返回

go">type User struct {ID     uintName   stringAge    intGender string// 假设后面还有几百个字段...
}type APIUser struct {ID   uintName string
}// 查询时会自动选择 `id`, `name` 字段
db.Model(&User{}).Limit(10).Find(&APIUser{})
// SELECT `id`, `name` FROM `users` LIMIT 10

子查询

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

from子查询

go">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` = 18subQuery1 := db.Model(&User{}).Select("name")
subQuery2 := db.Model(&Pet{}).Select("name")
db.Table("(?) as u, (?) as p", subQuery1, subQuery2).Find(&User{})

关联操作

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;

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

go">type UserProfile struct {ID     int64UserId int64Sex    intAge    int}func (u UserProfile) TableName() string {return "user_profiles"
}

保存User

go">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就会失败。

go">type User struct {ID          int64Username    string      `gorm:"column:username"`Password    string      `gorm:"column:password"`CreateTime  int64       `gorm:"column:createtime"`UserProfile UserProfile `gorm:"foreignKey:UserId"`
}

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

关联标签

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

查询

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

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

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

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

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

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

go">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)

http://www.ppmy.cn/ops/166144.html

相关文章

74.HarmonyOS NEXT ImageItemView组件深度剖析:组件基础结构与核心状态管理(一)

温馨提示&#xff1a;本篇博客的详细代码已发布到 git : https://gitcode.com/nutpi/HarmonyosNext 可以下载运行哦&#xff01; HarmonyOS NEXT ImageItemView组件深度剖析&#xff1a;组件基础结构与核心状态管理(一) 文章目录 HarmonyOS NEXT ImageItemView组件深度剖析&…

电路原理(电容 集成电路NE555)

电容 1.特性&#xff1a;充放电&#xff0c;隔直流&#xff0c;通交流 2.电容是通过聚集正负电荷来存储电能的 3.电容充放电过程可等效为导通回路 4.多电容并联可以把容量叠加&#xff0c;但是多电容串联就不会&#xff0c;只会叠加电容的耐压值。 6.电容充放电时相当于通路&a…

二叉树的层序遍历(102)

102. 二叉树的层序遍历 - 力扣&#xff08;LeetCode&#xff09; 解法&#xff1a; /*** Definition for a binary tree node.* struct TreeNode {* int val;* TreeNode *left;* TreeNode *right;* TreeNode() : val(0), left(nullptr), right(nullptr) {}* …

《Python实战进阶》No23: 使用 Selenium 自动化浏览器操作

No23: 使用 Selenium 自动化浏览器操作 摘要 Selenium 是自动化浏览器操作的“瑞士军刀”&#xff0c;可模拟人类行为操作网页&#xff0c;适用于爬虫、测试、重复任务自动化等场景。本集通过代码驱动实战&#xff0c;从安装配置到复杂交互&#xff0c;带你掌握 Selenium 的核…

【量化策略】双均线交叉策略

【量化策略】双均线交叉策略 &#x1f680;量化软件开通 &#x1f680;量化实战教程 技术背景与应用场景 双均线交叉策略是一种基于移动平均线的经典量化交易策略&#xff0c;广泛应用于股票、期货、外汇等金融市场。该策略通过计算短期和长期两条移动平均线的交叉点来生成…

软考网络安全专业

随着信息技术的迅猛发展&#xff0c;网络安全问题日益凸显&#xff0c;成为社会各界普遍关注的焦点。在这样的背景下&#xff0c;软考网络安全专业应运而生&#xff0c;为培养高素质的网络安全人才提供了有力支撑。本文将对软考网络安全专业进行深入剖析&#xff0c;探讨其在信…

C语言网络安全框架

坚决归零。。。 C语言应注意的基本编程规范&#xff1a; 1&#xff0c;文件名用小写字母、下划线、数字的组合命名&#xff0c;不可出现空格等其他字符&#xff0c;更不允许出现汉字、日语、俄语等 ASCII码字符。 2&#xff0c;每个.c文件都要对应一个.h文件来配合其对外资源声…

设计模式--单例模式(Singleton)【Go】

引言 在设计模式中&#xff0c;单例模式&#xff08;Singleton Pattern&#xff09;是一种非常常见且实用的模式。它的核心思想是确保一个类只有一个实例&#xff0c;并提供一个全局访问点。这种模式在需要全局唯一对象的场景中非常有用&#xff0c;比如配置管理、日志记录、数…