【Go学习】04-4-Gorm框架-增删改查
增删改查
插入数据
user := User{
Username:"zhangsan",
Password:"123456",
CreateTime:time.Now().Unix(),
}
db.Create(&user)
user.ID // 返回插入数据的主键
result.Error // 返回 error
result.RowsAffected // 返回插入记录的条数
用指定的字段创建
db.Select("username","password").Create(&user)
忽略字段
db.Omit("username").Create(&user)
批量插入
var users = []User{{Username: "jinzhu1"}, {Username: "jinzhu2"}, {Username: "jinzhu3"}}
db.Create(&users)
for _, user := range users {
user.ID // 1,2,3
}
使用 CreateInBatches 分批创建时，你可以指定每批的数量，例如：
var users = []User{{Username: "jinzhu_1"}, ...., {Username: "jinzhu_10000"}}
// 数量为 100
db.CreateInBatches(users, 100)
map创建
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表达式
DB.Model(&User{}).Create(map[string]interface{}{
"username": "jinzhu",
"password": clause.Expr{SQL: "md5(?)", Vars: []interface{}{"123456"}},
})
使用原生sql语句
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层
package dao
import (
"testing"
"time"
)
func TestSaveGoods(t *testing.T) {
goods := Goods{
Title: "毛巾",
Price: 25,
Stock: 100,
Type: 0,
CreateTime: time.Now(),
}
SaveGoods(goods)
}
保存数据
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)
更新单个列
goods := Goods{}
DB.Where("id = ?", 2).Take(&goods)
DB.Model(&goods).Update("title", "hello")
更新多列
goods := Goods{}
DB.Where("id = ?", 2).Take(&goods)
//更新非零值的字段 也可以使用map
DB.Model(&goods).Updates(Goods{
Title: "hello",
Stock: 200,
})
更新选定的字段
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")
表达式
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再传给数据库。
子查询更新
goods := Goods{}
DB.Where("id = ?", 2).Take(&goods)
DB.Model(&goods).Update("title", DB.Model(&User{}).Select("username").Where("id=?", 2))
删除数据
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
查询数据
查询函数
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)
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)
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)
order
排序
var goods []Goods
DB.Order("id desc").Find(&goods)
分页
通过limit和Offset实现
var goods []Goods
DB.Order("create_time desc").Limit(10).Offset(10).Find(&goods)
count
返回查询匹配的行数
var total int64 = 0
DB.Model(Goods{}).Count(&total)
fmt.Println(total)
分组
//统计每个商品分类下面有多少个商品
//定一个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函数一起使用
直接执行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
会话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 的更新操作
事务
自动事务
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 支持嵌套事务，您可以回滚较大事务内执行的一部分操作，例如：
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
手动事务
// 开始事务
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()
}
保存点
GORM 提供了 SavePoint、Rollbackto 方法，来提供保存点以及回滚至保存点功能，例如：
tx := db.Begin()
tx.Create(&user1)
tx.SavePoint("sp1")
tx.Create(&user2)
tx.RollbackTo("sp1") // Rollback user2
tx.Commit() // Commit user1
Hook
Hook 是在创建、查询、更新、删除等操作之前、之后调用的函数。
如果您已经为模型定义了指定的方法，它会在创建、更新、查询、删除时自动被调用。如果任何回调返回错误，GORM 将停止后续的操作并回滚事务。
钩子方法的函数签名应该是 func(*gorm.DB) error
创建
创建时可用的 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
}
更新
更新时可用的 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
}
删除
删除时可用的 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
}
查询
查询时可用的 hook
// 从 db 中加载数据
// Preloading (eager loading)
AfterFind
代码示例：
func (u *User) AfterFind(tx *gorm.DB) (err error) {
if u.MemberShip == "" {
u.MemberShip = "user"
}
return
}
高级查询
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)
智能选择字段
相当于对responce进行部分返回
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
子查询
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{})
关联操作
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"
}
保存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:UserId"`
}
只要给UserProfile添加上相应的tag即可。
关联标签
| 标签 | 描述 |
|---|---|
| foreignKey | 指定当前模型的列作为连接表的外键 |
| references | 指定引用表的列名，其将被映射为连接表外键 |
| polymorphic | 指定多态类型，比如模型名 |
| polymorphicValue | 指定多态值、默认表名 |
| many2many | 指定连接表表名 |
| joinForeignKey | 指定连接表的外键列名，其将被映射到当前表 |
| joinReferences | 指定连接表的外键列名，其将被映射到引用表 |
| constraint | 关系约束，例如：OnUpdate、OnDelete |
查询
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)