Gorm 的 Create 操作 源码分析

Gorm 是一款 ORM 框架,当我们想把一个对象/struct 持久化的时候,我们可以直接操作对象/struct 而不需要编写 SQL 语句,如下:

package main

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/jinzhu/gorm"
    "xg-temp/service/proto"
)

func main() {
    db, _ := gorm.Open("mysql",
        "root:123456" + "@/xg?charset=utf8&parseTime=true&loc=Local")

    ma := &xgtmp_srv_app.MobileApplication{
        AppName: "第一个应用",
        OtherInfo: "第一个应用的信息",
    }
    db.Create(ma)
}

db 中的结果:

mysql> use xg;
Database changed
mysql> select * from mobile_applications;
+-----------------+--------------------------+------------------+---------------+
| app_name        | other_info               | xxx_unrecognized | xxx_sizecache |
+-----------------+--------------------------+------------------+---------------+
| 第一个应用      | 第一个应用的信息         | NULL             |             0 |
+-----------------+--------------------------+------------------+---------------+
1 row in set (0.00 sec)

mysql>

很方便,但是 Create 操作背后的逻辑究竟是什么,只是简单的字段映射吗?还是有别的逻辑,我们只能深入源码去探究一番。

1 Create(value interface{}) *DB

首先创建了一个新的 scope,scope 用要持久化的对象来初始化。然后调用 scope 的 creates 回调函数,返回 db 对象,符合链式语法。

// Create insert the value into database
func (s *DB) Create(value interface{}) *DB {
    scope := s.NewScope(value)
    return scope.callCallbacks(s.parent.callbacks.creates).db
}

scope 是一个局部上下文,表示当前操作,如创建操作,涉及到的一些信息。

// Scope contain current operation's information when you perform any operation on the database
type Scope struct {
    Search          *search // 查询条件
    Value           interface{} // 对于 Create 来说即要持久化的对象
    SQL             string // 具体执行的 SQL 语句
    SQLVars         []interface{} // 要替换掉占位符的具体参数
    db              *DB // 数据库连接
    instanceID      string
    primaryKeyField *Field // 主键字段
    skipLeft        bool
    fields          *[]*Field // 所有字段
    selectAttrs     *[]string
}

newScope 操作,先是复制了当前连接的上下文,然后把要持久化的对象分别赋值给连接和 scope,如果当前连接有 search 则赋值给 scope 中的 search 属性。search 也是一个 struct,用来描述 SQL 查询语句的各种条件,比如 where, or, join, limit 等等。这里不深入研究。

// NewScope create a scope for current operation
func (s *DB) NewScope(value interface{}) *Scope {
    dbClone := s.clone()
    dbClone.Value = value
    scope := &Scope{db: dbClone, Value: value}
    if s.search != nil {
        scope.Search = s.search.clone()
    } else {
        scope.Search = &search{}
    }
    return scope
}

完成元数据的创建后,我们发现,后续操作直接委托给了 scope.callCallbacks(s.parent.callbacks.creates)。

2. scope.callCallbacks(s.parent.callbacks.creates)

callCallbacks 上来就以 defer 的形式定义了错误处理函数,我们在里面看见了 db.Rollback() 操作,肯定是事务回滚操作,但是我们并没有看见在哪里开启了事务,这个后面会解释。
主体部分很简单,funcs 是一个函数指针数组,函数的入参为 Scope 指针,遍历并执行每一个函数。skipLeft 属性的意义暂不清楚。

func (scope *Scope) callCallbacks(funcs []*func(s *Scope)) *Scope {
    defer func() {
        if err := recover(); err != nil {
            if db, ok := scope.db.db.(sqlTx); ok {
                db.Rollback()
            }
            panic(err)
        }
    }()
    for _, f := range funcs {
        (*f)(scope)
        if scope.skipLeft {
            break
        }
    }
    return scope
}

callCallbacks 的实参是 s.parent.callbacks.creates,s.parent 表示的是数据库连接的一些共有属性,全局共享。callbacks 的定义如下:

// Callback is a struct that contains all CRUD callbacks
//   Field `creates` contains callbacks will be call when creating object
//   Field `updates` contains callbacks will be call when updating object
//   Field `deletes` contains callbacks will be call when deleting object
//   Field `queries` contains callbacks will be call when querying object with query methods like Find, First, Related, Association...
//   Field `rowQueries` contains callbacks will be call when querying object with Row, Rows...
//   Field `processors` contains all callback processors, will be used to generate above callbacks in order
type Callback struct {
    logger     logger
    creates    []*func(scope *Scope)
    updates    []*func(scope *Scope)
    deletes    []*func(scope *Scope)
    queries    []*func(scope *Scope)
    rowQueries []*func(scope *Scope)
    processors []*CallbackProcessor
}

可见,creates 是一组函数,在我们执行 Create 操作的时候都会执行,那么 creates 具体是哪些函数呢?
在 gorm.callback_create 里定义了 init 函数,我们知道 init() 函数是一种特殊的函数,会在 package 被导入的时候有且仅执行一次。

func init() {
// 开启事务
    DefaultCallback.Create().Register("gorm:begin_transaction", beginTransactionCallback)
// Create 前的操作
    DefaultCallback.Create().Register("gorm:before_create", beforeCreateCallback)
// saveBeforeAssocations
    DefaultCallback.Create().Register("gorm:save_before_associations", saveBeforeAssociationsCallback)
// 更新时间
    DefaultCallback.Create().Register("gorm:update_time_stamp", updateTimeStampForCreateCallback)
// 执行 Create
    DefaultCallback.Create().Register("gorm:create", createCallback)
// 强制触发重新加载
    DefaultCallback.Create().Register("gorm:force_reload_after_create", forceReloadAfterCreateCallback)
// saveAfterAssociations
    DefaultCallback.Create().Register("gorm:save_after_associations", saveAfterAssociationsCallback)
// Create 后的操作
    DefaultCallback.Create().Register("gorm:after_create", afterCreateCallback)
// 提交或回滚事务
    DefaultCallback.Create().Register("gorm:commit_or_rollback_transaction", commitOrRollbackTransactionCallback)
}

一上来就注册了这么多回调?是的,你没看错。官方文档里也简单提了一下这部分,没被注释掉的是暴露出来的接口。

// begin transaction 开始事物
BeforeSave
BeforeCreate
// save before associations 保存前关联
// update timestamp `CreatedAt`, `UpdatedAt` 更新`CreatedAt`, `UpdatedAt`时间戳
// save self 保存自己
// reload fields that have default value and its value is blank 重新加载具有默认值且其值为空的字段
// save after associations 保存后关联
AfterCreate
AfterSave
// commit or rollback transaction 提交或回滚事务

下面我们一一来看

2.1 beginTransactionCallback

就一行,scope.Begin(),具体的工作委托给了 scope,而 scope 实际上直接把操作转发给了自己的 gorm.DB.db,这是一个 SQLCommon 接口类型,在初始化的过程中,实际类型就是 sql.DB。
sqlDB 接口暴露了 Begin 方法,所以,scope 开启事务,实际上调用的还是 sql.DB 里定义的相关方法。这部分操作在另一篇博客中有说明。
sqlDb 和 SQLCommon 是两个接口,虽然实际类型都是 sql.DB,但是需要转换一下。db.Begin() 后,scope 里就是开启了事务的连接了。

func beginTransactionCallback(scope *Scope) {
    scope.Begin()
}

// Begin start a transaction
func (scope *Scope) Begin() *Scope {
    if db, ok := scope.SQLDB().(sqlDb); ok {
        if tx, err := db.Begin(); scope.Err(err) == nil {
            scope.db.db = interface{}(tx).(SQLCommon)
            scope.InstanceSet("gorm:started_transaction", true)
        }
    }
    return scope
}

// SQLDB return *sql.DB
func (scope *Scope) SQLDB() SQLCommon {
    return scope.db.db
}
Begin 后 driverConn 已经绑定

2.2 beforeCreateCallback

beforeCreateCallback 会调用 BeforeSave 和 BeforeCreate 两个方法,

// beforeCreateCallback will invoke `BeforeSave`, `BeforeCreate` method before creating
func beforeCreateCallback(scope *Scope) {
    if !scope.HasError() {
        scope.CallMethod("BeforeSave")
    }
    if !scope.HasError() {
        scope.CallMethod("BeforeCreate")
    }
}

这两个方法是定义在我们的 struct 上的,即接收者为要被 Create 的 struct。如下:

func (m *MobileApplication) BeforeSave() {
    println("MobileApplication BeforeSave")
}

func (m *MobileApplication) BeforeCreate() {
    println("MobileApplication BeforeCreate")
}

在执行 Create 操作的时候会触发这两个方法。但是,这个方法不能参与到事务中,因为没有事务句柄。Gorm的官网给了下面的示例来解决这个问题:

gorm中的保存/删除操作正在事务中运行,因此在该事务中所做的更改不可见,除非提交。 如果要在回调中使用这些更改,则需要在同一事务中运行SQL。 所以你需要传递当前事务到回调,像这样:

func (u *User) AfterCreate(tx *gorm.DB) (err error) {
    tx.Model(u).Update("role", "admin")
    return
}
func (u *User) AfterCreate(scope *gorm.Scope) (err error) {
  scope.DB().Model(u).Update("role", "admin")
    return
}

2.3 saveBeforeAssociationsCallback

// TODO 没看懂

func saveBeforeAssociationsCallback(scope *Scope) {
    for _, field := range scope.Fields() {
        autoUpdate, autoCreate, saveReference, relationship := saveAssociationCheck(scope, field)

        if relationship != nil && relationship.Kind == "belongs_to" {
            fieldValue := field.Field.Addr().Interface()
            newScope := scope.New(fieldValue)

            if newScope.PrimaryKeyZero() {
                if autoCreate {
                    scope.Err(scope.NewDB().Save(fieldValue).Error)
                }
            } else if autoUpdate {
                scope.Err(scope.NewDB().Save(fieldValue).Error)
            }

            if saveReference {
                if len(relationship.ForeignFieldNames) != 0 {
                    // set value's foreign key
                    for idx, fieldName := range relationship.ForeignFieldNames {
                        associationForeignName := relationship.AssociationForeignDBNames[idx]
                        if foreignField, ok := scope.New(fieldValue).FieldByName(associationForeignName); ok {
                            scope.Err(scope.SetColumn(fieldName, foreignField.Field.Interface()))
                        }
                    }
                }
            }
        }
    }
}
if scope.changeableField(field) && !field.IsBlank && !field.IsIgnored {
        if r = field.Relationship; r != nil {
            autoUpdate, autoCreate, saveReference = true, true, true

            if value, ok := scope.Get("gorm:save_associations"); ok {
                autoUpdate = checkTruth(value)
                autoCreate = autoUpdate
                saveReference = autoUpdate
            } else if value, ok := field.TagSettingsGet("SAVE_ASSOCIATIONS"); ok {
                autoUpdate = checkTruth(value)
                autoCreate = autoUpdate
                saveReference = autoUpdate
            }

            if value, ok := scope.Get("gorm:association_autoupdate"); ok {
                autoUpdate = checkTruth(value)
            } else if value, ok := field.TagSettingsGet("ASSOCIATION_AUTOUPDATE"); ok {
                autoUpdate = checkTruth(value)
            }

            if value, ok := scope.Get("gorm:association_autocreate"); ok {
                autoCreate = checkTruth(value)
            } else if value, ok := field.TagSettingsGet("ASSOCIATION_AUTOCREATE"); ok {
                autoCreate = checkTruth(value)
            }

            if value, ok := scope.Get("gorm:association_save_reference"); ok {
                saveReference = checkTruth(value)
            } else if value, ok := field.TagSettingsGet("ASSOCIATION_SAVE_REFERENCE"); ok {
                saveReference = checkTruth(value)
            }
        }
    }

2.4 updateTimeStampForCreateCallback

这个很简单,就是在创建的时候设置 CreatedAt 和 UpdatedAt 字段

// updateTimeStampForCreateCallback will set `CreatedAt`, `UpdatedAt` when creating
func updateTimeStampForCreateCallback(scope *Scope) {
    if !scope.HasError() {
        now := scope.db.nowFunc()

        if createdAtField, ok := scope.FieldByName("CreatedAt"); ok {
            if createdAtField.IsBlank {
                createdAtField.Set(now)
            }
        }

        if updatedAtField, ok := scope.FieldByName("UpdatedAt"); ok {
            if updatedAtField.IsBlank {
                updatedAtField.Set(now)
            }
        }
    }
}

2.5 createCallback

执行真正的 INSERT 操作,也就是 ORM 逻辑。代码太长这里就不贴了。
需要注意的是,当字段为零值的时候,只有设置了 default 才会执行操作,而不是直接置为 NULL

if scope.changeableField(field) {
  if field.IsNormal && !field.IsIgnored {
    if field.IsBlank && field.HasDefaultValue {
      blankColumnsWithDefaultValue = append(blankColumnsWithDefaultValue, scope.Quote(field.DBName))
      scope.InstanceSet("gorm:blank_columns_with_default_value", blankColumnsWithDefaultValue)
    } else if !field.IsPrimaryKey || !field.IsBlank {
      columns = append(columns, scope.Quote(field.DBName))
      placeholders = append(placeholders, scope.AddToVars(field.Field.Interface()))
    }
  } else if field.Relationship != nil && field.Relationship.Kind == "belongs_to" {
    for _, foreignKey := range field.Relationship.ForeignDBNames {
      if foreignField, ok := scope.FieldByName(foreignKey); ok && !scope.changeableField(foreignField) {
        columns = append(columns, scope.Quote(foreignField.DBName))
        placeholders = append(placeholders, scope.AddToVars(foreignField.Field.Interface()))
      }
    }
  }
}

2.6 forceReloadAfterCreateCallback

把设置了 default 标识的字段赋值为当前对象的对应字段值

// forceReloadAfterCreateCallback will reload columns that having default value, and set it back to current object
func forceReloadAfterCreateCallback(scope *Scope) {
    if blankColumnsWithDefaultValue, ok := scope.InstanceGet("gorm:blank_columns_with_default_value"); ok {
        db := scope.DB().New().Table(scope.TableName()).Select(blankColumnsWithDefaultValue.([]string))
        for _, field := range scope.Fields() {
            if field.IsPrimaryKey && !field.IsBlank {
                db = db.Where(fmt.Sprintf("%v = ?", field.DBName), field.Field.Interface())
            }
        }
        db.Scan(scope.Value)
    }
}

2.7 saveAfterAssociationsCallback

// TODO 没看懂

2.8 afterCreateCallback

与前面的 beforeCreateCallback 类似

2.9 commitOrRollbackTransactionCallback

这个方法会调用 scope.CommitOrRollback()

// CommitOrRollback commit current transaction if no error happened, otherwise will rollback it
func (scope *Scope) CommitOrRollback() *Scope {
    if _, ok := scope.InstanceGet("gorm:started_transaction"); ok {
        if db, ok := scope.db.db.(sqlTx); ok {
            if scope.HasError() {
                db.Rollback()
            } else {
                scope.Err(db.Commit())
            }
            scope.db.db = scope.db.parent.db
        }
    }
    return scope
}
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 148,637评论 1 318
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 63,443评论 1 266
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 99,164评论 0 218
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 42,075评论 0 188
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 50,080评论 1 266
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 39,365评论 1 184
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 30,901评论 2 283
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,649评论 0 176
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 33,122评论 0 223
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,734评论 2 225
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,093评论 1 236
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,548评论 2 222
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 32,028评论 3 216
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,765评论 0 9
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,291评论 0 178
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 34,162评论 2 239
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 34,293评论 2 242

推荐阅读更多精彩内容