基于GORM实现CreateOrUpdate方法详解
作者：ag9920 发布时间：2024-02-14 09:18:02
CreateOrUpdate 是业务开发中很常见的场景，我们支持用户对某个业务实体进行创建/配置。希望实现的 repository 接口要达到以下两个要求：
如果此前不存在该实体，创建一个新的；
如果此前该实体已经存在，更新相关属性。
根据笔者的团队合作经验看，很多 Golang 开发同学不是很确定对于这种场景到底怎么实现，写出来的代码五花八门，还可能有并发问题。今天我们就来看看基于 GORM 怎么来实现 CreateOrUpdate。
GORM 写接口原理
我们先来看下 GORM 提供了那些方法来支持我们往数据库插入数据，对 GORM 比较熟悉的同学可以忽略这部分：
Create
插入一条记录到数据库，注意需要通过数据的指针来创建，回填主键；
// Create insert the value into database
func (db *DB) Create(value interface{}) (tx *DB) {
if db.CreateBatchSize > 0 {
return db.CreateInBatches(value, db.CreateBatchSize)
}
tx = db.getInstance()
tx.Statement.Dest = value
return tx.callbacks.Create().Execute(tx)
}
赋值 Dest 后直接进入 Create 的 callback 流程。
Save
保存所有的字段，即使字段是零值。如果我们传入的结构主键为零值，则会插入记录。
// Save update value in database, if the value doesn't have primary key, will insert it
func (db *DB) Save(value interface{}) (tx *DB) {
tx = db.getInstance()
tx.Statement.Dest = value
reflectValue := reflect.Indirect(reflect.ValueOf(value))
for reflectValue.Kind() == reflect.Ptr || reflectValue.Kind() == reflect.Interface {
reflectValue = reflect.Indirect(reflectValue)
}
switch reflectValue.Kind() {
case reflect.Slice, reflect.Array:
if _, ok := tx.Statement.Clauses["ON CONFLICT"]; !ok {
tx = tx.Clauses(clause.OnConflict{UpdateAll: true})
}
tx = tx.callbacks.Create().Execute(tx.Set("gorm:update_track_time", true))
case reflect.Struct:
if err := tx.Statement.Parse(value); err == nil && tx.Statement.Schema != nil {
for _, pf := range tx.Statement.Schema.PrimaryFields {
if _, isZero := pf.ValueOf(tx.Statement.Context, reflectValue); isZero {
return tx.callbacks.Create().Execute(tx)
}
}
}
fallthrough
default:
selectedUpdate := len(tx.Statement.Selects) != 0
// when updating, use all fields including those zero-value fields
if !selectedUpdate {
tx.Statement.Selects = append(tx.Statement.Selects, "*")
}
tx = tx.callbacks.Update().Execute(tx)
if tx.Error == nil && tx.RowsAffected == 0 && !tx.DryRun && !selectedUpdate {
result := reflect.New(tx.Statement.Schema.ModelType).Interface()
if result := tx.Session(&Session{}).Limit(1).Find(result); result.RowsAffected == 0 {
return tx.Create(value)
}
}
}
return
}
关注点：
在 reflect.Struct 的分支，判断 PrimaryFields 也就是主键列是否为零值，如果是，直接开始调用 Create 的 callback，这也和 Save 的说明匹配；
switch 里面用到了 fallthrough 关键字，说明 switch 命中后继续往下命中 default；
如果我们没有用 Select() 方法指定需要更新的字段，则默认是全部更新，包含所有零值字段，这里用的通配符 *
如果主键不为零值，说明记录已经存在，这个时候就会去更新。
事实上有一些业务场景下，我们可以用 Save 来实现 CreateOrUpdate 的语义：
首次调用时主键ID为空，这时 Save 会走到 Create 分支去插入数据。
随后调用时存在主键ID，触发更新逻辑。
但 Save 本身语义其实比较混乱，不太建议使用，把这部分留给业务自己实现，用Updates,Create用起来更明确些。
Update & Updates
Update 前者更新单个列。
Updates 更新多列，且当使用 struct 更新时，默认情况下，GORM 只会更新非零值的字段（可以用 Select 指定来解这个问题）。使用 map 更新时则会全部更新。
// Update update attributes with callbacks, refer: https://gorm.io/docs/update.html#Update-Changed-Fields
func (db *DB) Update(column string, value interface{}) (tx *DB) {
tx = db.getInstance()
tx.Statement.Dest = map[string]interface{}{column: value}
return tx.callbacks.Update().Execute(tx)
}
// Updates update attributes with callbacks, refer: https://gorm.io/docs/update.html#Update-Changed-Fields
func (db *DB) Updates(values interface{}) (tx *DB) {
tx = db.getInstance()
tx.Statement.Dest = values
return tx.callbacks.Update().Execute(tx)
}
这里也能从实现中看出来一些端倪。Update 接口内部是封装了一个 map[string]interface{}，而 Updates 则是可以接受 map 也可以走 struct，最终写入 Dest。
FirstOrInit
获取第一条匹配的记录，或者根据给定的条件初始化一个实例（仅支持 struct 和 map）
// FirstOrInit gets the first matched record or initialize a new instance with given conditions (only works with struct or map conditions)
func (db *DB) FirstOrInit(dest interface{}, conds ...interface{}) (tx *DB) {
queryTx := db.Limit(1).Order(clause.OrderByColumn{
Column: clause.Column{Table: clause.CurrentTable, Name: clause.PrimaryKey},
})
if tx = queryTx.Find(dest, conds...); tx.RowsAffected == 0 {
if c, ok := tx.Statement.Clauses["WHERE"]; ok {
if where, ok := c.Expression.(clause.Where); ok {
tx.assignInterfacesToValue(where.Exprs)
}
}
// initialize with attrs, conds
if len(tx.Statement.attrs) > 0 {
tx.assignInterfacesToValue(tx.Statement.attrs...)
}
}
// initialize with attrs, conds
if len(tx.Statement.assigns) > 0 {
tx.assignInterfacesToValue(tx.Statement.assigns...)
}
return
}
注意，Init 和 Create 的区别，如果没有找到，这里会把实例给初始化，不会存入 DB，可以看到 RowsAffected == 0 分支的处理，这里并不会走 Create 的 callback 函数。这里的定位是一个纯粹的读接口。
FirstOrCreate
获取第一条匹配的记录，或者根据给定的条件创建一条新纪录（仅支持 struct 和 map 条件）。FirstOrCreate可能会执行两条sql，他们是一个事务中的。
// FirstOrCreate gets the first matched record or create a new one with given conditions (only works with struct, map conditions)
func (db *DB) FirstOrCreate(dest interface{}, conds ...interface{}) (tx *DB) {
tx = db.getInstance()
queryTx := db.Session(&Session{}).Limit(1).Order(clause.OrderByColumn{
Column: clause.Column{Table: clause.CurrentTable, Name: clause.PrimaryKey},
})
if result := queryTx.Find(dest, conds...); result.Error == nil {
if result.RowsAffected == 0 {
if c, ok := result.Statement.Clauses["WHERE"]; ok {
if where, ok := c.Expression.(clause.Where); ok {
result.assignInterfacesToValue(where.Exprs)
}
}
// initialize with attrs, conds
if len(db.Statement.attrs) > 0 {
result.assignInterfacesToValue(db.Statement.attrs...)
}
// initialize with attrs, conds
if len(db.Statement.assigns) > 0 {
result.assignInterfacesToValue(db.Statement.assigns...)
}
return tx.Create(dest)
} else if len(db.Statement.assigns) > 0 {
exprs := tx.Statement.BuildCondition(db.Statement.assigns[0], db.Statement.assigns[1:]...)
assigns := map[string]interface{}{}
for _, expr := range exprs {
if eq, ok := expr.(clause.Eq); ok {
switch column := eq.Column.(type) {
case string:
assigns[column] = eq.Value
case clause.Column:
assigns[column.Name] = eq.Value
default:
}
}
}
return tx.Model(dest).Updates(assigns)
}
} else {
tx.Error = result.Error
}
return tx
}
注意区别，同样是构造 queryTx 去调用 Find 方法查询，后续的处理很关键：
若没有查到结果，将 where 条件，Attrs() 以及 Assign() 方法赋值的属性写入对象，从源码可以看到是通过三次 assignInterfacesToValue 实现的。属性更新后，调用 Create 方法往数据库中插入；
若查到了结果，但 Assign() 此前已经写入了一些属性，就将其写入对象，进行 Updates 调用。
第一个分支好理解，需要插入新数据。重点在于 else if len(db.Statement.assigns) > 0 分支。
我们调用 FirstOrCreate 时，需要传入一个对象，再传入一批条件，这批条件会作为 Where 语句的部分在一开始进行查询。而这个函数同时可以配合 Assign() 使用，这一点就赋予了生命力。
不管是否找到记录，Assign 都会将属性赋值给 struct，并将结果写回数据库。
方案一：FirstOrCreate + Assign
func (db *DB) Attrs(attrs ...interface{}) (tx *DB) {
tx = db.getInstance()
tx.Statement.attrs = attrs
return
}
func (db *DB) Assign(attrs ...interface{}) (tx *DB) {
tx = db.getInstance()
tx.Statement.assigns = attrs
return
}
这种方式充分利用了 Assign 的能力。我们在上面 FirstOrCreate 的分析中可以看出，这里是会将 Assign 进来的属性应用到 struct 上，写入数据库的。区别只在于是插入（Insert）还是更新（Update）。
// 未找到 user，根据条件和 Assign 属性创建记录
db.Where(User{Name: "non_existing"}).Assign(User{Age: 20}).FirstOrCreate(&user)
// SELECT * FROM users WHERE name = 'non_existing' ORDER BY id LIMIT 1;
// INSERT INTO "users" (name, age) VALUES ("non_existing", 20);
// user -> User{ID: 112, Name: "non_existing", Age: 20}
// 找到了 `name` = `jinzhu` 的 user，依然会根据 Assign 更新记录
db.Where(User{Name: "jinzhu"}).Assign(User{Age: 20}).FirstOrCreate(&user)
// SELECT * FROM users WHERE name = 'jinzhu' ORDER BY id LIMIT 1;
// UPDATE users SET age=20 WHERE id = 111;
// user -> User{ID: 111, Name: "jinzhu", Age: 20}
所以，要实现 CreateOrUpdate，我们可以将需要 Update 的属性通过 Assign 函数放进来，随后如果通过 Where 找到了记录，也会将 Assign 属性应用上，随后 Update。
这样的思路一定是可以跑通的，但使用之前要看场景。
为什么？
因为参看上面源码我们就知道，FirstOrCreate 本质是 Select + Insert 或者 Select + Update。
无论怎样，都是两条 SQL，可能有并发安全问题。如果你的业务场景不存在并发，可以放心用 FirstOrCreate + Assign，功能更多，适配更多场景。
而如果可能有并发安全的坑，我们就要考虑方案二：Upsert。
方案二：Upsert
鉴于 MySQL 提供了 ON DUPLICATE KEY UPDATE 的能力，我们可以充分利用唯一键的约束，来搞定并发场景下的 CreateOrUpdate。
import "gorm.io/gorm/clause"
// 不处理冲突
DB.Clauses(clause.OnConflict{DoNothing: true}).Create(&user)
// `id` 冲突时，将字段值更新为默认值
DB.Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "id"}},
DoUpdates: clause.Assignments(map[string]interface{}{"role": "user"}),
}).Create(&users)
// MERGE INTO "users" USING *** WHEN NOT MATCHED THEN INSERT *** WHEN MATCHED THEN UPDATE SET ***; SQL Server
// INSERT INTO `users` *** ON DUPLICATE KEY UPDATE ***; MySQL
// Update columns to new value on `id` conflict
DB.Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "id"}},
DoUpdates: clause.AssignmentColumns([]string{"name", "age"}),
}).Create(&users)
// MERGE INTO "users" USING *** WHEN NOT MATCHED THEN INSERT *** WHEN MATCHED THEN UPDATE SET "name"="excluded"."name"; SQL Server
// INSERT INTO "users" *** ON CONFLICT ("id") DO UPDATE SET "name"="excluded"."name", "age"="excluded"."age"; PostgreSQL
// INSERT INTO `users` *** ON DUPLICATE KEY UPDATE `name`=VALUES(name),`age=VALUES(age); MySQL
这里依赖了 GORM 的 Clauses 方法，我们来看一下：
type Interface interface {
Name() string
Build(Builder)
MergeClause(*Clause)
}
// AddClause add clause
func (stmt *Statement) AddClause(v clause.Interface) {
if optimizer, ok := v.(StatementModifier); ok {
optimizer.ModifyStatement(stmt)
} else {
name := v.Name()
c := stmt.Clauses[name]
c.Name = name
v.MergeClause(&c)
stmt.Clauses[name] = c
}
}
这里添加进来一个 Clause 之后，会调用 MergeClause 将语句进行合并，而 OnConflict 的适配是这样：
package clause
type OnConflict struct {
Columns []Column
Where Where
TargetWhere Where
OnConstraint string
DoNothing bool
DoUpdates Set
UpdateAll bool
}
func (OnConflict) Name() string {
return "ON CONFLICT"
}
// Build build onConflict clause
func (onConflict OnConflict) Build(builder Builder) {
if len(onConflict.Columns) > 0 {
builder.WriteByte('(')
for idx, column := range onConflict.Columns {
if idx > 0 {
builder.WriteByte(',')
}
builder.WriteQuoted(column)
}
builder.WriteString(`) `)
}
if len(onConflict.TargetWhere.Exprs) > 0 {
builder.WriteString(" WHERE ")
onConflict.TargetWhere.Build(builder)
builder.WriteByte(' ')
}
if onConflict.OnConstraint != "" {
builder.WriteString("ON CONSTRAINT ")
builder.WriteString(onConflict.OnConstraint)
builder.WriteByte(' ')
}
if onConflict.DoNothing {
builder.WriteString("DO NOTHING")
} else {
builder.WriteString("DO UPDATE SET ")
onConflict.DoUpdates.Build(builder)
}
if len(onConflict.Where.Exprs) > 0 {
builder.WriteString(" WHERE ")
onConflict.Where.Build(builder)
builder.WriteByte(' ')
}
}
// MergeClause merge onConflict clauses
func (onConflict OnConflict) MergeClause(clause *Clause) {
clause.Expression = onConflict
}
初阶的用法中，我们只需要关注三个属性：
DoNothing：冲突后不处理，参照上面的 Build 实现可以看到，这里只会加入 DO NOTHING；
DoUpdates: 配置一批需要赋值的 KV，如果没有指定 DoNothing，会根据这一批 Assignment 来写入要更新的列和值；
type Set []Assignment
type Assignment struct {
Column Column
Value interface{}
}
UpdateAll: 冲突后更新所有的值（非 default tag字段）。
需要注意的是，所谓 OnConflict，并不一定是主键冲突，唯一键也包含在内。所以，使用 OnConflict 这套 Upsert 的先决条件是【唯一索引】或【主键】都可以。生成一条SQL语句，并发安全。
如果没有唯一索引的限制，我们就无法复用这个能力，需要考虑别的解法。如果
总结
若你的 CreateOrUpdate 能用到【唯一索引】或【主键】，建议使用方案二，这也是作者金柱大佬最推荐的方案，并发安全；
若无法用【唯一索引】来限制，需要用其他列来判断，且不关注并发安全，可以采用方案一；
若只需要按照【主键】是否为零值来实现 CreateOrUpdate，可以使用 Save（接口语义不是特别明确，用的时候小心，如果可以，尽量用 Create/Update）。
来源：https://juejin.cn/post/7155840164504272933
0
投稿猜你喜欢
- 问题环境依赖OS： CentOS 7.2 Python 3.5问题提出在运行一个Python程序之时，在调用sqlite之时，碰到如下的错误
- 最近接触到一个心理学方面的理论：心流理论。大意是一种个人精力完全投注在某件事情上的感觉。心流产生时会有高度的兴奋和充实感。其实也就是说人在进
作为一个学完Python基础知识的测试，暗喜终于可以像RD们自己写脚本处理任何场景吧，如何优雅地写出来代码，接下来开启进阶版的Python。- 几天写过两篇使用VPS的安全性设置的博文，其实不管我们如何设置安全，及时的备份VPS数据才是最为重要的。因为VPS与主机不同，主机可能很多时
- 1.算法概述决策树算法是在已知各种情况发生概率的基础上，通过构成决策树来求取净现值的期望值大于等于零的概率，评价项目风险，判断其可行性的决策
- 前段时间我编写了一个工业控制的软件，在使用中一直存在一个问题，就是当软件检索设备时，因为这个功能执行的时间比较长，导致GUI界面假死，让用户
- 一.docx模块Python可以利用python-docx模块处理word文档，处理方式是面向对象的。也就是说python-docx模块会把
- 如下所示：import pandas as pdcontent = ['T', 'F'] * 10data
- 先放关键代码：i = tf.train.range_input_producer(NUM_EXPOCHES, num_epochs=1, s
- 与事件循环进行交互，最基本的方式就是任务，任务封装了协程和自动跟踪它的状态。任务是Future类的子类，所以其它协程可以等待任务完成，或当这
- 本文为大家分享了python八皇后问题的解决方法，供大家参考，具体内容如下题目：给定一个 N*N 正方形棋盘，在上面放置 N个棋子，又叫皇后
- 下面是Sql Server 和 Access 操作数据库结构的常用Sql，希望对你有所帮助。内容由海娃整理，不正确与不完整之处还请提出，谢谢
- fnamtch就是filenamematch, 在python中利用符合linuxshell风格的匹配模块来进行文件名的匹配筛选工作。fnm
- 想不到大家都这么喜欢用python给女朋友挑钻石，所以我又写了个续。如果看过之前一篇用python挑钻石的文章，那么可以直接从箱线图开始读。
- 环境准备创建QQ互联应用创建一个QQ互联应用，并获取到App ID和App Key。QQ互联官网：https://connect.qq.co
- 1、说明写了python文件，想通过命令执行它，进入目录，并在命令执行中输入python文件名称。2、实例例如，桌子上有文件hello.py
- 一、前言Python提供两种方法进行字符串格式化1、利用百分号来格式化字符串，现在Python已停止更新这种方法2、字符串的format方法
- 正二十面体的顶点正20面体的12个顶点刚好可以分为三组，每一组都是一个符合黄金分割比例的长方形，而且这三个长方形是互相正交的。所以，想绘制一
- 这篇文章主要给大家介绍了利用Thinkphp结合ajaxFileUpload实现异步图片传输的方法，文中给出了详细的示例代码，对大家具有一定
- 很早很早的时候，computer这个东西习惯于被称之为计算机，因为它的主要功能是完成一些科学计算的东西，我记得自己鼓捣它的时候，就是计算，根
