Go入门之Gorm 框架

Gorm简介

gorm是Golang语言中一款性能极好的ORM库，对开发人员相对是比较友好的。当然还有另外一个xorm库也是比较出名的，感兴趣的也可以看看这个库，接下来主要介绍下gorm库的一些基本使用。
下面我们一起看看如何安装这个gorm框架，然后快速的把它使用起来

//安装MySQL驱动
go get -u gorm.io/driver/mysql
go get -u github.com/jinzhu/gorm

Gorm连接数据库

1.首先我们先来看看如何使用Gorm连接数据库

package main

import (
	"fmt"
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

var DB *gorm.DB //后续用于操作数据库
func init() {
	//配置MySQL连接参数
	username := "root"       //账号
	password := "lyz"        //密码
	host := "43.138.224.118" //数据库地址，可以是Ip或者域名
	port := 3306             //数据库端口
	Dbname := "gorm"         //数据库名
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, Dbname)
	db, err := gorm.Open("mysql", dsn)
	if err != nil {
		panic("连接数据库失败, error=" + err.Error())
	}
	DB = db
}
func main() {

}

Gorm进行数据库基本操作

GORM操作MySQL
再进行操作MySQL数据库之前，劳烦各位铁子再先将数据库给建好，连接好数库后输入以下命令当然再这里博主的数据库名字就叫做gorm

create database gorm;

假设我们需要再数据库里面键一张表，那么对应的建表语句可以是如下这个

CREATE TABLE `users` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `username` varchar(30) NOT NULL COMMENT '账号',
  `password` varchar(100) NOT NULL COMMENT '密码',
  `createtime` bigint(20) NOT NULL DEFAULT 0 COMMENT '创建时间',
   PRIMARY KEY (`id`)
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4

那么对应用GORM来定义那么它是这样的

//定义User模型，绑定users表，ORM库操作数据库，需要定义一个struct类型和MYSQL表进行绑定或者叫映射，struct字段和MYSQL表字段一一对应
type User struct {
    ID int64 // 主键
	//通过在字段后面的标签说明，定义golang字段和表字段的关系
	//例如 `gorm:"column:username"` 标签说明含义是: Mysql表的列名（字段名)为username
	Username string `gorm:"column:username"`
	Password string `gorm:"column:password"`
	//创建时间，时间戳
	CreateTime int64 `gorm:"column:createtime"`
}

当然这里需要说明以下，这个在这个Gorm当中默认是将这个ID字段做为主键如果我们不显示的指定某个字段为主键
下面我们就用Gorm来定义一张表吧，然后去数据库里面看以下这个情况是如何的

package main

import (
	"fmt"
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

var DB *gorm.DB //后续用于操作数据库

// User 定义User模型，绑定users表，ORM库操作数据库，需要定义一个struct类型和MYSQL表进行绑定或者叫映射，struct字段和MYSQL表字段一一对应
type User struct {
	ID int64 // 主键
	//通过在字段后面的标签说明，定义golang字段和表字段的关系
	//例如 `gorm:"column:username"` 标签说明含义是: Mysql表的列名（字段名)为username
	Username string `gorm:"column:username"`
	Password string `gorm:"column:password"`
	//创建时间，时间戳
	CreateTime int64 `gorm:"column:createtime"`
}

func init() {
	//配置MySQL连接参数
	username := "root"       //账号
	password := "lyz"        //密码
	host := "43.138.224.118" //数据库地址，可以是Ip或者域名
	port := 3306             //数据库端口
	Dbname := "gorm"         //数据库名
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, Dbname)
	db, err := gorm.Open("mysql", dsn)
	if err != nil {
		panic("连接数据库失败, error=" + err.Error())
	}
	DB = db
}

func main() {
    //创建表
	DB.AutoMigrate(&User{}) //在这里传指针的原因是指针占用的空间少
}

AutoMigrate 用于自动迁移你的 schema，保持 schema 是最新的。 该 API 会创建表、缺失的外键、约束、列和索引。 如果大小、精度、是否为空可以更改，则 AutoMigrate 会改变列的类型。出于保护数据的目的，它 不会 删除未使用的列。
下面我们去数据库里面看看这个表是什么样子的

我们发现表的名字后面多了一个s，这也是这个Gorm的风格当然如果我们想要这个定义成这个我们想要的名字我们只需要给这个结构体添加一个TableName方法，对应如下：

func(u*User)TableName()string{
	return "user"//你希望他的名字是什么就填什么
}

当然如果我们不希望这个gorm默认的将我们的表设置为这个负数形式我们可以使用这个函数来进行处理

// 禁用默认表名的复数形式，如果置为 true，则 `User` 的默认表名是 `user`
DB.SingularTable(true)

当然Gorm还提供了自动默认的建表风格，我们可以将这个默认的表名前面或者后面添加一些东西也是可以的

gorm.DefaultTableNameHandler = func (db *gorm.DB, defaultTableName string) string  {
  return "prefix_" + defaultTableName;
}

除了上面这种方式来建表，还有这种方式也可以来建表。

DB.Table("USER").CreateTable(&User{})

除了建表当然还有判断某个表是否存在，删除表等操作，一起来看看吧感受gorm的强大之处
1.判断某个表是否存在

// 检查模型是否存在
db.HasTable(&User{})
// 检查表是否存在
db.HasTable("users")

2.删除表

// 删除表
db.DropTable(&User{})
db.DropTable("users")//

3.修改表

// 修改列(修改字段类型)
db.Model(&User{}).ModifyColumn("description", "text")
// 删除列
db.Model(&User{}).DropColumn("description")

下面说一下这个gorm当中结构体标签和数据库是怎么对应起来的

关联相关标记（tags）

下面博主举几个例子来演示一下这个结构体tag在gorm当中的用法
1。模型定义默认情况下，GORM 会使用 ID 作为表的主键。

type User struct {
  ID   string // 默认情况下，名为 `ID` 的字段会作为表的主键
  Name string
}

如果你当前的表主键不是 id 字段，那么你可以通过 primaryKey标签将其它字段设为主键：

// 将 `UUID` 设为主键
type Animal struct {
  ID     int64
  UUID   string `gorm:"primaryKey"`
  Name   string
  Age    int64
}

当然也可以有这个复合主键。

type Product struct {
  ID           string `gorm:"primaryKey"`
  LanguageCode string `gorm:"primaryKey"`
  Code         string
  Name         string
}

注意：默认情况下，整型 PrioritizedPrimaryField 启用AutoIncrement，要禁用它，铁子们需要为整型字段关闭 autoIncrement

type Product struct {
  CategoryID uint64 `gorm:"primaryKey;autoIncrement:false"`
  TypeID     uint64 `gorm:"primaryKey;autoIncrement:false"`
}

使用GORM 通过在 struct 上定义自定义的 gorm 标签来实现自动化创建表的功能：

type User struct {
	Name string  `gorm:"size:255"` //string默认长度255,size重设长度
	Age int `gorm:"column:my_age"` //设置列名为my_age
	Num int  `gorm:"AUTO_INCREMENT"` //自增
	IgnoreMe int `gorm:"-"` // 忽略字段
	Email string `gorm:"type:varchar(100);unique_index"` //type设置sql类型，unique_index为该列设置唯一索引
	Address string `gorm:"not null;unique"` //非空
	No string `gorm:"index:idx_no"` // 创建索引并命名，如果有其他同名索引，则创建组合索引
	Remark string `gorm:"default:''"` //默认值
}

定义好之后在用上面的建表语句就可以将我们定义的结构体和数据库中的表对应起来。下面我们说一下这个默认模型
GORM 定义一个 gorm.Model 结构体，其包括字段 ID、CreatedAt、UpdatedAt、DeletedAt。其结构如下：

// gorm.Model 的定义
type Model struct {
  ID        uint           `gorm:"primaryKey"`
  CreatedAt time.Time
  UpdatedAt time.Time
  DeletedAt gorm.DeletedAt `gorm:"index"`
}

如果铁子们觉得上面这几个字段名字段名是你想要的，那么完全可以在铁子你的模型中引入它：

type User struct {
	gorm.Model
	Id    int64  `json:"id"`
	Name  string `json:"name"`
	Age   int32  `json:"age"`
	Sex   int8   `json:"sex"`
	Phone string `json:"phone"`
}

最后关于这个数据库最级别的操作我们在看最后一个这个时间戳跟踪
如果我们建的表有CreatedAt，UpdatedAt，DeletedAt这三个字段。

如果模型有 CreatedAt字段，该字段的值将会是初次创建记录的时间。

db.Create(&user) // `CreatedAt`将会是当前时间
// 可以使用`Update`方法来改变`CreateAt`的值
db.Model(&user).Update("CreatedAt", time.Now())

如果模型有UpdatedAt字段，该字段的值将会是每次更新记录的时间。

db.Save(&user) // `UpdatedAt`将会是当前时间

db.Model(&user).Update("name", "jinzhu") // `UpdatedAt`将会是当前时间

如果模型有DeletedAt字段，调用Delete删除该记录时，将会设置DeletedAt字段为当前时间，而不是直接将记录从数据库中删除。

Gorm 对数据库进行CURD

CRUD通常指数据库的增删改查操作，本文详细介绍了如何使用GORM实现创建、查询、更新和删除操作。
本文中的DB变量为*gorm.DB对象.下面我们从这个最简单的开始往数据库里面插入一条数据

package main

import (
	"fmt"
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

var DB *gorm.DB //后续用于操作数据库

type User struct {
	ID   int64
	Name string `gorm:"default:'小王子'"` //我们不填的默认值
	Age  int64
}

func (u *User) TableName() string {
	return "user" //你希望他的名字是什么就填什么
}

func init() {
	//配置MySQL连接参数
	username := "root"       //账号
	password := "lyz"        //密码
	host := "43.138.224.118" //数据库地址，可以是Ip或者域名
	port := 3306             //数据库端口
	Dbname := "gorm"         //数据库名
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, Dbname)
	db, err := gorm.Open("mysql", dsn)
	if err != nil {
		panic("连接数据库失败, error=" + err.Error())
	}
	DB = db
}

func main() {
	DB.AutoMigrate(&User{})
	user := User{Name: "ksy", Age: 18}
	DB.NewRecord(user) // 主键为空返回`true`
	DB.Create(&user)   // 创建user忘数据库里面插入一条数据
	DB.NewRecord(user) // 创建`user`后返回`false`
}

我们发现这个数据库里面的数据确实是我们设置的。当然我们也可以选择性的插入这个字段。
1.选择性插入值

func main() {
	user := User{ID: 2, Name: "kuangsiyuan", Age: 12}
	DB.Select("id", "name").Create(&user)
}

对应数据库情况

2.忽略字段

func main() {
	user := User{ID: 3, Name: "kuangsiyuan", Age: 12}
	DB.Omit("name").Create(&user)
}

我们发现确实这个Name字段使用了默认值，也就是忽略了它。
3.使用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},
})

最后说一下这个默认值这里有一个小小的坑：通过tag定义字段的默认值，在创建记录时候生成的 SQL 语句会排除没有值或值为 零值 的字段。 在将记录插入到数据库后，Gorm会从数据库加载那些字段的默认值。什么意思了下面我们来使用一个例子解释一下

func main() {
	user:=User{ID: 4,Name: "",Age: 20}
	DB.Create(&user)
}

在这里我们插入的这个值为这个"“，我们想要他插入的值是这个但是结果真的是我们想要的吗？我们执行一下然后再去数据库里面查看

我们发现他使用的是这个默认值，但是如果我们就是想要插入这个”"字符串这个时候该怎么办了？此时可以考虑使用指针或实现 Scanner/Valuer接口，比如
使用指针

// 使用指针
type User struct {
  ID   int64
  Name *string `gorm:"default:'小王子'"`
  Age  int64
}
user := User{Name: new(string), Age: 18))}
db.Create(&user)  // 此时数据库中该条记录name字段的值就是''

在这里给出伪代码，就不一个一个实验了铁子们可以下来实验一下。

2.使用Scanner/Valuer接口方式实现零值存入数据库

// 使用 Scanner/Valuer
type User struct {
	ID int64
	Name sql.NullString `gorm:"default:'小王子'"` // sql.NullString 实现了Scanner/Valuer接口
	Age  int64
}
user := User{Name: sql.NullString{"", true}, Age:18}
db.Create(&user)  // 此时数据库中该条记录name字段的值就是''

当然我们也可以使用这个原生的sql语句来进行这个插入操作

	DB.Exec("insert into users (username,password,createtime) values (?,?,?)", user.Username, user.Password, user.CreateTime)

下面我们来看看这个查询数据

// 根据主键查询第一条记录
db.First(&user)
 SELECT * FROM users ORDER BY id LIMIT 1;

// 随机获取一条记录
db.Take(&user)
 SELECT * FROM users LIMIT 1;

// 根据主键查询最后一条记录
db.Last(&user)
 SELECT * FROM users ORDER BY id DESC LIMIT 1;

// 查询所有的记录这里users定义的是数组
db.Find(&users)
 SELECT * FROM users;

// 查询指定的某条记录(仅当主键为整型时可用)
db.First(&user, 10)
 SELECT * FROM users WHERE id = 10;

下面我们演示一个就可以了，这些都比较的容易懂。

func main() {
	 var user User
	 DB.First(&user)//注意需要传递指针否则无法赋值
	 fmt.Printf("the user is %#v",user)
}

func main() {
	var user User
	DB.First(&user) //注意需要传递指针否则无法赋值
	fmt.Printf("the user is %#v\n", user)
	var users = make([]*User, 10)
	DB.Find(&users)
	fmt.Printf("the users is %#v\n", users)
}

当 First、Last、Take 方法找不到记录时，GORM 会返回 ErrRecordNotFound 错误，可以通过对比gorm.ErrRecordNotFound进行判断，或者使用Find和Limit的组合进行查询。

db.Limit(1).Find(&user)

下面我们看看这个Where条件的SQL查询

// Get first matched record
db.Where("name = ?", "ksy").First(&user)
 SELECT * FROM users WHERE name = 'jinzhu' limit 1;

// Get all matched records
db.Where("name = ?", "ksy").Find(&users)
 SELECT * FROM users WHERE name = 'jinzhu';

// <>
db.Where("name <> ?", "ksy").Find(&users)
 SELECT * FROM users WHERE name <> 'jinzhu';

// IN
db.Where("name IN (?)", []string{"jinzhu", "jinzhu 2"}).Find(&users)
 SELECT * FROM users WHERE name in ('jinzhu','jinzhu 2');

// LIKE
db.Where("name LIKE ?", "%jin%").Find(&users)
 SELECT * FROM users WHERE name LIKE '%jin%';

// AND
db.Where("name = ? AND age >= ?", "ksy", "22").Find(&users)
 SELECT * FROM users WHERE name = 'jinzhu' AND age >= 22;

// Time
db.Where("updated_at > ?", lastWeek).Find(&users)
 SELECT * FROM users WHERE updated_at > '2000-01-01 00:00:00';

// BETWEEN
db.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&users)
 SELECT * FROM users WHERE created_at BETWEEN '2000-01-01 00:00:00' AND '2000-01-08 00:00:00';

这个非常的容易懂，同样的博主也只演示一下

func main() {
	var user User
	DB.Where("id=?", 1).First(&user)
	fmt.Printf("the user is %v", user)
}

当然我们可以选择性返回某些字段的值

func main() {
	var user User
	DB.Debug().Select("id,name").Where("id=?", 2).First(&user)
	fmt.Printf("the user is %#v", user)

}

这个Debug可以将这个sql语句给打印出来，方便我们进行dbug.下面我们看看这个几个这个特殊的查询Struct & Map查询

// Struct
db.Where(&User{Name: "ksy", Age: 20}).First(&user)
 SELECT * FROM users WHERE name = "ksy" AND age = 20 LIMIT 1;

// Map
db.Where(map[string]interface{}{"name": "ksy", "age": 20}).Find(&users)
 SELECT * FROM users WHERE name = "ksy" AND age = 20;

// 主键的切片
db.Where([]int64{20, 21, 22}).Find(&users)
 SELECT * FROM users WHERE id IN (20, 21, 22)

提示：当通过结构体进行查询时，GORM将会只通过非零值字段查询，这意味着如果你的字段值为0，‘’，false或者其他零值时，将不会被用于构建查询条件.这个很多铁子可能就会踩这个坑。
我们可以使用指针或实现 Scanner/Valuer 接口来避免这个问题，和那个插入是一样的在这里就不演示了

Or条件

db.Where("role = ?", "admin").Or("role = ?", "super_admin").Find(&users)
 SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';

// Struct
db.Where("name = 'ksy'").Or(User{Name: "ksy 2"}).Find(&users)
 SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';

// Map
db.Where("name = 'ksy'").Or(map[string]interface{}{"name": "ksy 2"}).Find(&users)
 SELECT * FROM users WHERE name = 'ksy' OR name = 'ksy 2';

内联条件

// 根据主键获取记录 (只适用于整形主键)
db.First(&user, 23)
 SELECT * FROM users WHERE id = 23 LIMIT 1;
// 根据主键获取记录, 如果它是一个非整形主键
db.First(&user, "id = ?", "string_primary_key")
 SELECT * FROM users WHERE id = 'string_primary_key' LIMIT 1;

// Plain SQL
db.Find(&user, "name = ?", "jinzhu")
 SELECT * FROM users WHERE name = "jinzhu";

db.Find(&users, "name <> ? AND age > ?", "jinzhu", 20)
 SELECT * FROM users WHERE name <> "jinzhu" AND age > 20;

// Struct
db.Find(&users, User{Age: 20})
 SELECT * FROM users WHERE age = 20;

// Map
db.Find(&users, map[string]interface{}{"age": 20})
 SELECT * FROM users WHERE age = 20;

下面我们在看看这个如果未找到，赋给它指定的值：

// 未找到
db.Where(User{Name: "non_existing"}).Attrs(User{Age: 20}).FirstOrInit(&user)
 SELECT * FROM USERS WHERE name = 'non_existing';
 user -> User{Name: "non_existing", Age: 20}

db.Where(User{Name: "non_existing"}).Attrs("age", 20).FirstOrInit(&user)
 SELECT * FROM USERS WHERE name = 'non_existing';
 user -> User{Name: "non_existing", Age: 20}

// 找到
db.Where(User{Name: "Jinzhu"}).Attrs(User{Age: 30}).FirstOrInit(&user)
 SELECT * FROM USERS WHERE name = jinzhu';
 user -> User{Id: 111, Name: "Jinzhu", Age: 20}

下面我们看几个这个高级查询来看看
首先第一个字查询

db.Where("amount > ?", db.Table("orders").Select("AVG(amount)").Where("state = ?", "paid").SubQuery()).Find(&orders)
// SELECT * FROM "orders"  WHERE "orders"."deleted_at" IS NULL AND (amount > (SELECT AVG(amount) FROM "orders"  WHERE (state = 'paid')));

排序

db.Order("age desc, name").Find(&users)
 SELECT * FROM users ORDER BY age desc, name;

// 多字段排序
db.Order("age desc").Order("name").Find(&users)
 SELECT * FROM users ORDER BY age desc, name;

// 覆盖排序
db.Order("age desc").Find(&users1).Order("age", true).Find(&users2)
 SELECT * FROM users ORDER BY age desc; (users1)
 SELECT * FROM users ORDER BY age; (users2)

总数
Count，该 model 能获取的记录总数。

db.Where("name = ?", "jinzhu").Or("name = ?", "jinzhu 2").Find(&users).Count(&count)
 SELECT * from USERS WHERE name = 'jinzhu' OR name = 'jinzhu 2'; (users)
 SELECT count(*) FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2'; (count)

db.Model(&User{}).Where("name = ?", "jinzhu").Count(&count)
 SELECT count(*) FROM users WHERE name = 'jinzhu'; (count)

db.Table("deleted_users").Count(&count)
 SELECT count(*) FROM deleted_users;

db.Table("deleted_users").Select("count(distinct(name))").Count(&count)
 SELECT count( distinct(name) ) FROM deleted_users; (count)

扫描

type Result struct {
  Name string
  Age  int
}

var result Result
db.Table("users").Select("name, age").Where("name = ?", "Antonio").Scan(&result)

var results []Result
db.Table("users").Select("name, age").Where("id > ?", 0).Scan(&results)

// 原生 SQL
db.Raw("SELECT name, age FROM users WHERE name = ?", "Antonio").Scan(&result)

查询看完了之后我们来看看这个更新
Save()默认会更新该对象的所有字段，即使你没有赋值。

db.First(&user)

user.Name = "七米"
user.Age = 99
db.Save(&user)

如果你只希望更新指定字段，可以使用Update或者Updates

// 更新单个属性，如果它有变化
db.Model(&user).Update("name", "hello")
 UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111;

// 根据给定的条件更新单个属性
db.Model(&user).Where("active = ?", true).Update("name", "hello")
 UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111 AND active=true;

// 使用 map 更新多个属性，只会更新其中有变化的属性
db.Model(&user).Updates(map[string]interface{}{"name": "hello", "age": 18, "active": false})
 UPDATE users SET name='hello', age=18, active=false, updated_at='2013-11-17 21:34:10' WHERE id=111;

// 使用 struct 更新多个属性，只会更新其中有变化且为非零值的字段
db.Model(&user).Updates(User{Name: "hello", Age: 18})
 UPDATE users SET name='hello', age=18, updated_at = '2013-11-17 21:34:10' WHERE id = 111;

// 警告：当使用 struct 更新时，GORM只会更新那些非零值的字段
// 对于下面的操作，不会发生任何更新，"", 0, false 都是其类型的零值
db.Model(&user).Updates(User{Name: "", Age: 0, Active: false})

如果想要选定字段更新

db.Model(&user).Select("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "active": false})
 UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111;

db.Model(&user).Omit("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "active": false})
 UPDATE users SET age=18, active=false, updated_at='2013-11-17 21:34:10' WHERE id=111;

下面我们在来看看这个删除操作
警告 删除记录时，请确保主键字段有值，GORM 会通过主键去删除记录，如果主键为空，GORM 会删除该 model 的所有记录。

// 删除现有记录
db.Delete(&email)
 DELETE from emails where id=10;

// 为删除 SQL 添加额外的 SQL 操作
db.Set("gorm:delete_option", "OPTION (OPTIMIZE FOR UNKNOWN)").Delete(&email)
 DELETE from emails where id=10 OPTION (OPTIMIZE FOR UNKNOWN);

注意如果有这个DeleteAt字段那么是这个软删除，如果我们想要真正的删除，我们需要这个使用Unscope

// Unscoped 方法可以物理删除记录
DB.Unscoped().Delete(&order)
 DELETE FROM orders WHERE id=10;

事物Transaction

1.自动事务

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
})

2.嵌套事物
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
})

3.手动事物

// 开始事务
tx := db.Begin()

// 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'）
tx.Create(...)

// ...

// 遇到错误时回滚事务
tx.Rollback()

// 否则，提交事务
tx.Commit()