Go 常用包: 全功能 ORM 框架-gorm- 使用

1. 介紹

gorm是一個使用Go語言編寫的ORM框架。它文檔齊全，對開發者友好，支持主流數據庫。官方中文文檔 https://gorm.io/zh_CN/docs/index.html

2. 安裝

go get -u gorm.io/gorm
go get -u gorm.io/driver/sqlite

3. 連接 MYSQL

GORM 官方支持的數據庫類型有：MySQL, PostgreSQL, SQlite, SQL Server, 這裏只講常見的MYSQL。其他類型數據庫參見官方文檔。

3.1 安裝mysql依賴

go get -u gorm.io/driver/mysql

3.2 建立連接

a. 默認連接

// 默認連接
func ConnectMysqlByDefault(host, port, user, pass, dbname string) (*gorm.DB, error) {
 // user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local
 dns := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
  user, pass, host, port, dbname)
 return gorm.Open(mysql.Open(dns), &gorm.Config{})
}

b. 自定義配置連接

// 自定義配置連接
func ConnectMysqlByCustom(host, port, user, pass, dbname string) (*gorm.DB, error) {
 // user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local
 dns := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
  user, pass, host, port, dbname)
 return gorm.Open(mysql.New(mysql.Config{
  DSN:                       dns,
  DefaultStringSize:         256,   // string 類型字段的默認長度
  DisableDatetimePrecision:  true,  //禁用 datetime 精度，MySQL 5.6 之前的數據庫不支持
  DontSupportRenameIndex:    true,  //重命名索引時採用刪除並新建的方式，MySQL 5.7 之前的數據庫和 MariaDB 不支持重命名索引
  DontSupportRenameColumn:   true,  //用change重命名列，MySQL8之前的數據庫和 MariaDB 不支持重命名列
  SkipInitializeWithVersion: false, // 根據當前 MySQL 版本自動配置
 }))
}

c. 基於database/sql連接

// 基於database/sql連接，進行二次封裝
func ConnectMysqlByDatabaseSql(host, port, user, pass, dbname string) (*gorm.DB, error) {
 dns := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
  user, pass, host, port, dbname)
 db, err := sql.Open("mysql", dns)
 if err != nil {
  return nil, err
 }
 return gorm.Open(mysql.New(mysql.Config{Conn: db}))
}

gorm.Config配置使用, 參見官方文檔: https://gorm.io/zh_CN/docs/gorm_config.html

4. 聲明模型

4.1 什麼是模型

模型其實就是標準的結構體 (struct), 其屬性和表結構的字段按照 gorm 約定 一一對應。約定如下:

• gorm使用ID作爲主鍵, 對應表中的id。

• 使用結構體名的 蛇形複數 作爲表名。對於結構體 User，根據約定，其表名爲 users

• 使用 CreatedAt、UpdatedAt 字段追蹤創建、更新時間。

gorm 定義一個 gorm.Model 結構體，其包括字段 ID、CreatedAt、UpdatedAt、DeletedAt, 其他結構體直接匿名嵌套即可。

4.2 字段標籤

Ml6Mvr

更多約定，請查看官方文檔

4.3 創建用戶模型

按照gorm約定創建用戶模型, 便於後面使用。用戶模型如下

// 用戶模型
type User struct {
 gorm.Model
 NickName     string         `gorm:"type:varchar(20);not null;default:'';comment:暱稱"`
 Age          uint8          `gorm:"size:4;comment:年齡"`
 Phone        string         `gorm:"type:char(11);index:un_phone;comment:手機號"`
 MemberNumber string         `gorm:"type:varchar(20);index:un_phone;comment:會員編號"`
 Birthday     sql.NullString `gorm:"type:varchar(10);comment:生日"`
 ActivatedAt  sql.NullTime   `gorm:"comment:激活時間"`
}

5. 遷移

5.1 根據模型生成表結構

根據上面創建的用戶模型User，生成對應的表結構

a. 代碼

// 自動遷移schema,(根據結構體創建或者更新schema)
func GormAutoMigrate(host, port, use, pass, database string) error {
  // ConnectMysqlByDefault 代碼參見上面的: 默認連接
 mysqlByDefault, err := ConnectMysqlByDefault(host, port, use, pass, database)
 if err != nil {
  return err
 }
 // 指定引擎和表備註
 err = mysqlByDefault.Set("gorm:table_options", "ENGINE=InnoDB COMMENT='用戶表'").AutoMigrate(&User{})
 if err != nil {
  return err
 }
 return nil
}

// 測試遷移
func TestAutoMigrate(t *testing.T) {
 host := "127.0.0.1"
 use,pass,port,database := "root","root","3306","test"
 err := gorme.GormAutoMigrate(host, port, use, pass, database)
 if err != nil {
  t.Error(err)
 }
 fmt.Println("創建表結構完成!")
}

b. 生成的表結構如下:

CREATE TABLE `users` (
  `id` bigint unsigned NOT NULL AUTO_INCREMENT,
  `created_at` datetime(3) DEFAULT NULL,
  `updated_at` datetime(3) DEFAULT NULL,
  `deleted_at` datetime(3) DEFAULT NULL,
  `nick_name` varchar(20) COLLATE utf8mb4_bin NOT NULL DEFAULT '' COMMENT '暱稱',
  `age` tinyint unsigned DEFAULT NULL COMMENT '年齡',
  `phone` char(11) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '手機號',
  `member_number` varchar(20) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '會員編號',
  `birthday` varchar(10) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '生日',
  `activated_at` datetime(3) DEFAULT NULL COMMENT '激活時間',
  PRIMARY KEY (`id`),
  KEY `idx_users_deleted_at` (`deleted_at`),
  KEY `un_phone` (`phone`,`member_number`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='用戶表';

6.CRUD

6.1 初始化客戶端

// 定義包內全局變量
var mysqlClient *gorm.DB
// 初始化mysql客戶端
func init()  {
 // 連接客戶端
 host := "127.0.0.1"
 user, pass, port, database := "root", "root", "3306", "test"
 databaseSql, _ := gorme.ConnectMysqlByDatabaseSql(host, port, user, pass, database)
 mysqlClient = databaseSql
}

6.2 單條插入

// 保存一條記錄
func TestAddOne(t *testing.T) {
 // 初始化結構體
 userRow := gorme.User{
  NickName:     "李四",
  Age:          18,
  Phone:        "12340000",
  MemberNumber: "A0001",
  Birthday:     sql.NullString{String: "1991-03-04",Valid: true},
  ActivatedAt:  sql.NullTime{Time: time.Now(),Valid: true},
 }
 // 傳入指針
 result := mysqlClient.Create(&userRow)
 fmt.Println(result)
 fmt.Println("id: ",userRow.ID)
 fmt.Println("插入記錄錯誤: ",result.Error)
 fmt.Println("插入記錄的條數: ",result.RowsAffected)
}
/*** 輸出
=== RUN   TestAddOne
&{0xc000184240 <nil> 1 0xc0001a21c0 0}
id:  1
插入記錄錯誤:  <nil>
插入記錄的條數:  1
--- PASS: TestAddOne (0.04s)
PASS
*/

6.3 批量插入

// 批量插入
func TestBatchInsert(t *testing.T) {
 // 定義user 切片
  userRows := []gorme.User{
  {NickName: "路人甲", Age: 20, Phone: "20000000", MemberNumber: "A0002"},
  {NickName: "路人乙", Age: 22, Phone: "30000000", MemberNumber: "A0003"},
  {NickName: "路人丙", Age: 24, Phone: "40000000", MemberNumber: "A0004"},
 }
 // 保存
 result := mysqlClient.Create(&userRows)
 fmt.Println("插入記錄錯誤: ", result.Error)
 fmt.Println("插入記錄的條數: ", result.RowsAffected)
 // 打印ID
 for _, row := range userRows {
  fmt.Println("插入ID: ", row.ID)
 }
}
/** 輸出
=== RUN   TestBatchInsert
插入記錄錯誤:  <nil>
插入記錄的條數:  3
插入ID:  4
插入ID:  5
插入ID:  6
--- PASS: TestBatchInsert (0.02s)
PASS
*/

更新插入方式，參見文檔: https://gorm.io/zh_CN/docs/create.html

6.4 查詢

a. 單條記錄: First、Take、Last

• First:  獲取第一條記錄（主鍵升序）

• Take: 獲取一條記錄，沒有指定排序字段

• Last: 獲取最後一條記錄（主鍵降序）

// 使用提供的First、Take、Last，查詢單條記錄
func TestGetOne(t *testing.T) {
 // 定義對應的結構體變量存儲結果
 var firstUser gorme.User
 var taskUser gorme.User
 var lastUser gorme.User
 var result *gorm.DB
 // 獲取第一條記錄（主鍵升序） SELECT * FROM users ORDER BY id LIMIT 1;
 result = mysqlClient.First(&firstUser)
 fmt.Printf("First Result: %+v\n", result.RowsAffected)
 // 獲取一條記錄，沒有指定排序字段 SELECT * FROM users LIMIT 1;
 result = mysqlClient.Take(&taskUser)
 fmt.Printf("Take Result: %+v\n", result.RowsAffected)
 // 獲取最後一條記錄（主鍵降序）SELECT * FROM users ORDER BY id DESC LIMIT 1;
 result = mysqlClient.Last(&lastUser)
 fmt.Printf("lastUser Result: %+v\n", result.RowsAffected)
}

@注意: 如果表裏沒有數據，會報錯result.Error返回:ErrRecordNotFound, 可以使用下面語句檢查錯誤。如果想避免ErrRecordNotFound錯誤，你可以使用Find, 如:db.Limit(1).Find(&user)

// 檢查 ErrRecordNotFound 錯誤
errors.Is(result.Error, gorm.ErrRecordNotFound)

b. 多條記錄: Find

// 使用Find(默認查詢的是檢索全部)
func TestGetByFind(t *testing.T) {
 var userList []gorme.User
 // 指針查詢字段
 result := mysqlClient.Select("id", "nick_name").Find(&userList)
 for _, user := range userList {
  fmt.Printf("id: %d nick_name: %s \n", user.ID,user.NickName)
 }
 fmt.Println("查詢記錄數: ", result.RowsAffected)
 fmt.Println("查詢錯誤: ", result.Error)
}
/** 輸出
=== RUN   TestGetByFind
id: 2 nick_name: 李四 
id: 3 nick_name: 張三 
id: 4 nick_name: 路人甲 
id: 5 nick_name: 路人乙 
id: 6 nick_name: 路人丙 
查詢記錄數:  5
查詢錯誤:  <nil>
--- PASS: TestGetByFind (0.00s)
PASS
*/

c. 條件查詢

1. String 條件

// 根據String條件查詢
func TestGetByStringWhere(t *testing.T) {
 // 定義對應的結構體變量
 var user gorme.User
 var userList []gorme.User
 var result *gorm.DB
 // 字符串條件查詢一條
 result = mysqlClient.Where("nick_name = ?", "張三").First(&user)
 fmt.Printf("Res1: %v err:%v \n", result.RowsAffected,result.Error)
 // 字符串條件查詢多條
 result = mysqlClient.Where("nick_name <> ?", "張三").Find(&userList)
 fmt.Printf("Res2: %v err:%v \n", result.RowsAffected,result.Error)
 // 多個條件
 result = mysqlClient.Where("nick_name = ? and age >= ?", "張三", 18).First(&user)
 fmt.Printf("Res3: %v err:%v \n", result.RowsAffected,result.Error)
}
/** 輸出
=== RUN   TestGetByStringWhere
Res1: 1 err:<nil> 
Res2: 4 err:<nil> 
Res3: 1 err:<nil> 
--- PASS: TestGetByStringWhere (0.02s)
PASS
*/

2. Struct 和 Map 條件

// 根據struct和map 條件查詢結果
func TestGetByStructAndMapWhere(t *testing.T) {
 // 定義對應的結構體變量
 var user gorme.User
 var userList []gorme.User
 var result *gorm.DB
 // 結構體條件
 result = mysqlClient.Where(&gorme.User{NickName: "張三",Age: 18}).First(&user)
 fmt.Printf("結構體條件: %+v err:%v \n", result.RowsAffected,result.Error)
 // map條件
 result = mysqlClient.Where(map[string]interface{}{"age":18}).Find(&userList)
 fmt.Printf("map條件: %+v err:%v \n", result.RowsAffected,result.Error)
 // 主鍵切片
 result = mysqlClient.Where([]int64{2,3,4,5}).Find(&userList)
 fmt.Printf("主鍵切片: %+v err:%v \n", result.RowsAffected,result.Error)
}
/** 輸出
=== RUN   TestGetByStructAndMapWhere
結構體條件: 1 err:<nil> 
map條件: 3 err:<nil> 
主鍵切片: 4 err:<nil> 
--- PASS: TestGetByStructAndMapWhere (0.01s)
PASS
*/

@注意 當使用結構作爲條件查詢時，GORM 只會查詢非零值字段。這意味着如果您的字段值爲 0、''、false 或其他 零值，該字段不會被用於構建查詢條件，例如：

db.Where(&User{NickName: "張三", Age: 0}).Find(&users)
// SELECT * FROM users WHERE name = "張三";

更多查詢規則和方法，見: https://gorm.io/zh_CN/docs/query.html

6.5 更新

a. 更新單個字段

// 更新單個字段
func TestUpdateColumn(t *testing.T) {
 var result *gorm.DB
 // 字符串條件更新
 // UPDATE users SET nick_name='張三A', updated_at=當前時間 WHERE nick_name='張三;
 result = mysqlClient.Model(&gorme.User{}).Where("nick_name = ?", "張三").
  Update("nick_name", "張三A")
 fmt.Printf("條件更新: %+v err:%v \n", result.RowsAffected, result.Error)
 // 結構體條件更新
 // UPDATE users SET age=28, updated_at=當前時間 WHERE member_number='A0001;
 result = mysqlClient.Model(&gorme.User{}).Where(&gorme.User{MemberNumber: "A0001"}).Update("age",28)
 fmt.Printf("結構體條件更新: %+v err:%v \n", result.RowsAffected, result.Error)
}
/** 輸出
=== RUN   TestUpdateColumn
條件更新: 1 err:<nil> 
結構體條件更新: 1 err:<nil> 
--- PASS: TestUpdateColumn (0.06s)
PASS
*/

b. 更新多個字段

// 更新多個字段
func TestUpdateMultipleColumn(t *testing.T) {
 var result *gorm.DB
 // 使用map
 updateMap := map[string]interface{}{
  "age":      32,
  "birthday": "1991-01-05",
 }
 // UPDATE users SET age=32,birthday='1991-01-05',updated_at=當前時間 WHERE id=6;
 result = mysqlClient.Model(&gorme.User{}).Where("id = ?", 6).Updates(updateMap)
 fmt.Printf("使用map結構更新: %+v err:%v \n", result.RowsAffected, result.Error)
 // 使用結構體(不使用Select)
 updateUser := gorme.User{
  Birthday: sql.NullString{String: "1993-10-10", Valid: true},
  Age:      0,
 }
 // @注意這裏的age=0不會更新到MySQL
 // UPDATE users SET birthday='1993-09-09',updated_at=當前時間 WHERE id=5;
 result = mysqlClient.Model(&gorme.User{}).Where("id = ?", 5).Updates(updateUser)
 fmt.Printf("使用struct結構更新: %+v err:%v \n", result.RowsAffected, result.Error)
 // 使用結構體(使用Select)
 updateUser2 := gorme.User{
  Birthday: sql.NullString{String: "1993-09-09", Valid: true},
  Age:      0,
 }
 // UPDATE users SET birthday='1993-09-09',age=0,updated_at=當前時間 WHERE id=4;
 result = mysqlClient.Model(&gorme.User{}).
  Select("birthday", "age"). //指定要更新的字段
  Where("id = ?", 4).Updates(updateUser2)
 fmt.Printf("使用struct結構更新2: %+v err:%v \n", result.RowsAffected, result.Error)
}

6.6 刪除

a. 軟刪除

// 刪除數據
func TestSoftDel(t *testing.T) {
 var result *gorm.DB
 // 根據主鍵，刪除一條記錄
 result = mysqlClient.Delete(&gorme.User{},1)
 fmt.Printf("根據主鍵刪除一條: %+v err:%v \n", result.RowsAffected, result.Error)
 // 根據主鍵切片，刪除多條記錄
 result = mysqlClient.Delete(&gorme.User{},[]int64{2,3})
 fmt.Printf("根據主鍵切片刪除多條: %+v err:%v \n", result.RowsAffected, result.Error)
 // 根據條件刪除
 result = mysqlClient.Where("age = ?",0).Delete(&gorme.User{})
 fmt.Printf("根據條件刪除: %+v err:%v \n", result.RowsAffected, result.Error)
}

執行上面代碼後，發現表裏面的記錄依然存在，而DeletedAt 置爲當前時間。原因是user模型中包含了一個 gorm.DeletedAt 字段，它將自動獲得軟刪除的能力！

b. 永久刪除

可以使用 Unscoped 永久刪除匹配的記錄。

// 刪除數據(硬刪除)
func TestStrongDel(t *testing.T) {
 var result *gorm.DB
 result = mysqlClient.Unscoped().Delete(&gorme.User{}, 1)
 fmt.Printf("硬刪除: %+v err:%v \n", result.RowsAffected, result.Error)
}

6.7 事務

a. 使用Transaction

// 事務使用(Transaction)
func TestTransaction(t *testing.T) {
 err := mysqlClient.Transaction(func(tx *gorm.DB) error {
  //在事務中執行一些 db 操作（從這裏開始，您應該使用 'tx' 而不是 'db'）
  // 創建用戶記錄
  user := gorme.User{NickName: "老王", Age: 48}
  if err := tx.Create(&user).Error; err != nil {
   // 回滾事務
   return err
  }
  // 創建用戶地址
  userAddress := gorme.UserAddress{Uid: user.ID, Province: "北京", City: "北京", Area: "海淀區"}
  if err := tx.Create(&userAddress).Error; err != nil {
   // 回滾事務
   return err
  }
  return nil
 })
 if err != nil {
  t.Error(err)
 }
 fmt.Println("執行完成")
}

b. 手動事務

// 手動事務
func TestUseManualTx(t *testing.T) {
    // 用戶表
 user := gorme.User{NickName: "小麗", Age: 19}
 // 開啓事務
 tx := mysqlClient.Begin()
 // 添加用戶
 if err := tx.Create(&user).Error; err != nil {
  // 遇到錯誤時回滾事務
  fmt.Println("添加用戶失敗: ",err)
  tx.Rollback()
 }
 // 用戶地址表
 userAddress := gorme.UserAddress{Uid: user.ID, Province: "北京", City: "北京", Area: "昌平區"}
 // 添加用戶地址
 if err := tx.Create(&userAddress).Error; err != nil {
  // 遇到錯誤時回滾事務
  fmt.Println("添加用戶地址失敗: ",err)
  tx.Rollback()
 }
 // 提交事務
 tx.Commit()
 fmt.Println("執行完成")
}

@注意: 在實踐中發現，執行時雖然事務失敗，但是主鍵依然遞增。具體看下圖效果:

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/uQ3KOpRwtwNQoeAjNSne9A