腾讯技术面：聊聊Go语言最强ORM框架GORM

var user User
db := db.Model(user).Select("age", "name").Where("age = ?", 18).Or("name = ?", "tencent").Find(&user)
if err := db.Error; err != nil {
  log.Printf("Find fail, err: %v", err)
}

func (db *DB) Select(query interface{}, args ...interface{}) (tx *DB) {
   tx := db.getInstance()
   switch v.(type){
   case string:
     for _, arg := range args {
       switch arg = arg.(type) {
       case string:
           tx.Statement.Selects = append(tx.Statement.Selects, arg)
       case []string:
           tx.Statement.Selects = append(tx.Statement.Selects, arg...)
       case default:
           ...
	}
    }
  case default:
      // 略
  }
}

func (db *DB) Where(query interface{}, args ...interface{}) (tx *DB) {
    tx = db.getInstance()
// 解析查询条件并将查询条件添加到Statement.Clauses中
    if conds := tx.Statement.BuildCondition(query, args...); len(conds) > 0 {
       tx.Statement.AddClause(clause.Where{Exprs: conds})
    }
    return
}

(db *DB) Find(dest interface{}, conds ...interface{}) (tx *DB){
  tx = db.getInstance()
  if len(conds) > 0 {
    // 解析Find方法自带的条件
    if exprs := tx.Statement.BuildCondition(conds[0], conds[1:]...); len(exprs) > 0 {
      tx.Statement.AddClause(clause.Where{Exprs: exprs})
    }
  }
  tx.Statement.Dest = dest

    // 构建SQL语句
  BuildQuerySQL(tx)

  // 若设置DryRun为true，则只输出SQL语句不执行
  if tx.DryRun || tx.Error != nil {return}

  // 将SQL语句发送到对应数据库执行并接收返回结果
  rows, err := tx.Statement.ConnPool.QueryContext(tx.Statement.Context, tx.Statement.SQL.String(), db.Statement.Vars...)
  if err != nil {
    db.AddError(err)
    return
  }

  // 解析结果并封装到tx.Statement.Dest中
  gorm.Scan(rows, tx, 0)
  if db.Statement.Result != nil {
    db.Statement.Result.RowsAffected = db.RowsAffected
  }
}

db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
    NamingStrategy: schema.NamingStrategy{
        SingularTable: true, // 关闭复数表名
    },
})

type Model struct {
    ID        uint `gorm:"primarykey"`
    CreatedAt time.Time
    UpdatedAt time.Time
    DeletedAt DeletedAt `gorm:"index"`
}

type Author struct {
  Name  string `gorm:"column:name"`
  Email string `gorm:"column:email"`
}
// 使用gorm embed功能
type Blog1 struct {
  ID      int 	 `gorm:"column:id"`
  Author  Author `gorm:"embedded";embeddedPrefix:author_`
  Upvotes int32  `gorm:"column:upvotes"`
}
// 属性平铺
type Blog2 struct {
  ID      int 	 `gorm:"column:id"`
  Upvotes int32  `gorm:"column:upvotes"`
  Name  string `gorm:"column:author_name"`
  Email string `gorm:"column:author_email"`
}

var users []User 
// First 查询第一条符合条件的记录，SQL 会自动加 LIMIT 1 
db.Where("age > ?", 18).First(&user) 
// SELECT * FROM users WHERE age > 18 ORDER BY id LIMIT 1;

// Find 查询所有符合条件的记录 
db.Where("age > ?", 18).Find(&users)
// SELECT * FROM users WHERE age > 18;

// 下列两条查询SQL是等价的
db.Find(&user, "status = ? and update_time < ?", 1, time.Now())
db.Where("status = ? and update_time < ?", 1, time.Now()).Find(&user)

var ages []int64
// 下列两条查询SQL是等价的
db.Model(&User{}).Pluck("age", &ages)
db.Model(&User{}).Select("age").Find(&ages)

// 根据 `struct` 更新属性，只会更新非零值的字段
db.Model(&user).Updates(User{ID: 111, Name: "hello", Age: 18, Active: false})
// UPDATE users SET name='hello', age=18 WHERE id = 111;

db.Model(&user).Updates(map[string]interface{}{"id": 111, "name": "hello", "age": 18, "active": false})
// UPDATE users SET name='hello', age=18, active=false WHERE id=111;

db.Model(&user).Select("name", "age", "active").Updates(User{ID: 111, Name: "hello", Age: 18, Active: false})
// UPDATE users SET name='hello', age=18, active=false WHERE id=111;

mysqlDB := mysql.Open("root:xxxxxxxx@tcp(127.0.0.1:3306)/smallProgram?charset=utf8mb4&parseTime=True&loc=Local")
db, err := gorm.Open(mysqlDB, &gorm.Config{
    AllowGlobalUpdate: true,
})

mysqlDB := mysql.Open("root:twk123456@tcp(127.0.0.1:3306)/smallProgram?charset=utf8mb4&parseTime=True&loc=Local")
db, err := gorm.Open(mysqlDB, &gorm.Config{
    DryRun:                 true,
})

func parseDSNParams(cfg *Config, params string) (err error) {
  for _, v := range strings.Split(params, "&") {
    key, value, found := strings.Cut(v, "=")
    if !found {continue}
    switch key{
    case "loc":
      // 存储设置的Loc属性，通常设置为Local
      cfg.Loc, err = time.LoadLocation(value)
      if err != nil {
        return
      }
    ......
    }
  }
}

// 设置loc属性为localLoc
func (t Time) In(loc *Location) Time {
    if loc == nil {
       panic("time: missing Location in call to Time.In")
    }
    t.setLoc(loc)
    return t
}

func (t Time) absSec() absSeconds {
  l = t.loc
  if l == nil || l == &localLoc{
    l = l.get()
  }
  sec := t.unixSec()
  if l != &utcLoc {
    if l.cacheZone != nil && l.cacheStart <= sec && sec < l.cacheEnd {
      // 一般情况，设置了CST时间后，会走这个分支添加偏移量
      sec += int64(l.cacheZone.offset)
    } else {
      _, offset, _, _, _ := l.lookup(sec)
      sec += int64(offset)
    }
  }
  return absSeconds(sec + (unixToInternal + internalToAbsolute))
}

var Local *Location = &localLoc
var localLoc Location
// 初始化并返回time库固有的localLoc对象
func (l *Location) get() *Location {
    if l == nil {
       return &utcLoc
    }
    // 第一次获取localLoc进行初始化
    if l == &localLoc {
       localOnce.Do(initLocal)
    }
    return l
}
// 初始化localLoc对象，主要就是读取系统文件并解析出时区信息
func initLocal() {
  tz, ok := syscall.Getenv("TZ")
  switch {
  case !ok:
    // 读取系统的/etc/localtime文件并解析
    z, err := loadLocation("localtime", []string{"/etc"})
    if err == nil {
      localLoc = *z
      localLoc.name = "Local"
      return
    }
  .......
}

func Delete(config *Config) func(db *gorm.DB) {
  return func(db *gorm.DB){
      // 开启软删除会走该分支，AddClause方法会填写SQL语句，导致删除实际为Update语句
      if db.Statement.Schema != nil {
      for _, c := range db.Statement.Schema.DeleteClauses {
        db.Statement.AddClause(c)
      }
    }
    // 未开启软删除走该分支，执行真正的Delete语句
    if db.Statement.SQL.Len() == 0 {
      ......
      db.Statement.Build(db.Statement.BuildClauses...)
    }
    if db.DryRun || db.Error != nil {return}
    // 发送SQL语句至数据库允许并接收返回结果
    result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
    ......
  }
}

type Values struct {
    Columns []Column
    Values  [][]interface{}
}

func ConvertToCreateValues(stmt *gorm.Statement) (values clause.Values) {
    ......
    // 设置Columns长度为数据库表属性个数
    values = clause.Values{Columns: make([]clause.Column, 0, len(stmt.Schema.DBNames))}
    switch stmt.ReflectValue.Kind() {
    case reflect.Slice, reflect.Array:
      // 设置批量对象的属性值
      values.Values = make([][]interface{}, stmt.ReflectValue.Len())
      for i := 0; i < stmt.ReflectValue.Len(); i++ {
        // 读取批量对象中指定索引对应对象
        rv := reflect.Indirect(stmt.ReflectValue.Index(i))
        values.Value[i] = make([]interface{}, len(values.Columns))
        // 遍历对象所有属性，将所有属性的值设置到第i个对象中
        for idx, column := range values.Columns {
          field := stmt.Schema.FieldsByDBName[column.Name]
          values.Values[i][idx], _ = field.ValueOf(stmt,Context, rv)
        }
      }
    case reflect.Struct:
      // 设置单个对象的属性值
      values.Values = [][]interface{}{make([]interface{}, len(values.Columns))}
      for idx, column := range values.Columns {
        field := stmt.Schema.FieldsByDBName[column.Name]
        values.Values[0][idx], _ = field.ValueOf(stmt,Context, rv)
      }
   }
}

tx := db.Begin()
err := tx.Select("name", "age").Where("id = ?", 1).Find(&user).Error
if err != nil {
  return err
}
tx.Commit()

// 截取部分go-sql-driver/mysql库逻辑
func (mc *mysqlConn) begin(readOnly bool) (driver.Tx, error) {
    if mc.closed.Load() {
       return nil, driver.ErrBadConn
    }
    var q string
    if readOnly {
       q = "START TRANSACTION READ ONLY"
    } else {
       q = "START TRANSACTION"
    }
    err := mc.exec(q)
    if err == nil {
       return &mysqlTx{mc}, err
    }
    return nil, mc.markBadConn(err)
}

ZoneGorm.WithContext(ctx).Clauses(clause.OnConflict{
  UpdateAll: true,
}).CreateInBatches(&infos, 50).Error

// 生成的SQL语句
INSERT INTO new_direct_buy_shop_product_info (Field1, Field2, ...) 
VALUES (?, ?), (?, ?), ... 
ON DUPLICATE KEY UPDATE 
id = id, Field1 = Field1, Field2 = Field2

// Create create hook
  func Create(config *Config) func(db *gorm.DB) {
    return func(db *gorm.DB){
    ......
    if db.Statement.SQL.Len() == 0 {
      // SQL语句构建
      db.Statement.Build(db.Statement.BuildClauses...)
    }
    // 判断是否开启试运行功能
    isDryRun := !db.DryRun && db.Error == nil
    if !isDryRun {
      return
    }
    // 实际发送SQL到数据库执行的函数
    rows, err := db.Statement.ConnPool.QueryContext(
      db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...,
    )
    ......
  }
}