Golang-Gorm-快速上手

Gorm文档

GORM文档地址

安装依赖

 go get -u "gorm.io/driver/mysql"
 go get -u "gorm.io/gorm"
1
2

连接数据库

默认连接方式

func main() {
  // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
  dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
  db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
}
1
2
3
4
5

想要正确的处理 time.Time ，需要带上 parseTime 参数， charset=utf8mb4可以支持表情

自定义配置连接数据库

	dsn := "root:root@tcp(127.0.0.1:3306)/learn_gorm?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.New(mysql.Config{
		DSN:                       dsn,   // DSN data source name
		DefaultStringSize:         256,   // string 类型字段的默认长度 如果该字段是字符串并作为主键会造成索引超长
		DisableDatetimePrecision:  true,  // 禁用 datetime 精度，MySQL 5.6 之前的数据库不支持
		DontSupportRenameIndex:    true,  // 重命名索引时采用删除并新建的方式，MySQL 5.7 之前的数据库和 MariaDB 不支持重命名索引
		DontSupportRenameColumn:   true,  // 用 `change` 重命名列，MySQL 8 之前的数据库和 MariaDB 不支持重命名列
		SkipInitializeWithVersion: false, // 根据当前 MySQL 版本自动配置
	}), &gorm.Config{ //连接的配置
		SkipDefaultTransaction: false, // 默认false，增删改都是事务操作来保证数据一致性，能提升一点性能
		NamingStrategy: schema.NamingStrategy{
			TablePrefix:         "",    // 如果设置了会给每个表名加前缀
			SingularTable:       false, // 单数表名，如果false会在表明后加s
			NameReplacer:        nil,   // 字符转转换器，转换字段名
			NoLowerCase:         false, //当设置为true时，NoLowerCase选项将禁用表名和列名的蛇形命名转换。保持表名和列名的原始大小写形式。
			IdentifierMaxLength: 0,     //不限制数据库标识符（如表名、列名）的最大长度。
		},
		Logger:                                   nil,  // 可以自定义日志
		DisableForeignKeyConstraintWhenMigrating: true, //true时，建表将不会建立物理外键，代码中我们采用逻辑外键提升数据库操作效率
	})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

数据库连接池配置

sqlDB, err := db.DB()
// 设置最大连接数量
sqlDB.SetMaxIdleConns(10)

// 连接池最多可容纳的连接数量
sqlDB.SetMaxOpenConns(100)

// 连接池中连接最常生命周期
sqlDB.SetConnMaxLifetime(time.Hour)
1
2
3
4
5
6
7
8
9

数据库logger日志

Gorm 有一个 默认 logger 实现，默认情况下，它会打印慢 SQL 和错误， 我们可以定义自己的 logger，Logger 需要实现以下接口，它接受 context，所以可以用它来追踪日志

type Interface interface {
    LogMode(LogLevel) Interface
    Info(context.Context, string, ...interface{})
    Warn(context.Context, string, ...interface{})
    Error(context.Context, string, ...interface{})
    Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error)
}
1
2
3
4
5
6
7

	_default := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags), logger.Config{
		SlowThreshold: 200 * time.Millisecond,
		LogLevel:      logger.Warn,
		Colorful:      true,
	})


1
2
3
4
5
6
7
8

模型

Gorm认为约定优于配置，即通过一些默认约定来简化配置和操作数据库。它提供了许多默认行为和命名约定。
GORM中默认采用ID作为主键，结构体名的蛇形复数作为表名，字段名的蛇形作为列名字，并使用CreatedAt,UpdateAt字段追踪创建、更新时间。
例如：

type User struct {
	ID        uint
	FirstName string
	LastName  string
	Email     string
	CreatedAt time.Time
	UpdatedAt time.Time
}
/*
据GORM的默认约定，上述结构体将映射到以下表结构：

表名: users（结构体名User的蛇形复数）
列名: id（自动生成的主键列名）
列名: first_name（结构体字段FirstName的蛇形命名）
列名: last_name（结构体字段LastName的蛇形命名）
列名: email（结构体字段Email的蛇形命名）
列名: created_at（结构体字段CreatedAt的蛇形命名）
列名: updated_at（结构体字段UpdatedAt的蛇形命名）
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

创建模型

创建模型文档地址

package models

import (
	"gorm.io/gorm"
)

type User struct {
	gorm.Model
	Avatar   string `json:"headerImg" gorm:"default:https://qmplusimg.henrongyi.top/gva_header.jpg;comment:用户头像"` // 用户头像
	Username string `json:"userName" gorm:"index;comment:用户登录名"`                                                  // 用户登录名
	Password string `json:"-"  gorm:"comment:用户登录密码"`                                                             // 用户登录密码
	NickName string `json:"nickName" gorm:"default:系统用户;comment:用户昵称"`                                            // 用户昵称
	Phone    string `json:"phone"  gorm:"comment:用户手机号"`                                                          // 用户手机号
	Email    string `json:"email"  gorm:"comment:用户邮箱"`                                                           // 用户邮箱
	Enable   int    `json:"enable" gorm:"default:1;comment:用户是否被冻结 1正常 2冻结"`                                      //用户是否被冻结 1正常 2冻结
	Roles    []Role `json:"Role" gorm:"many2many:user_role;"`
}
// 表名
func (User) TableName() string {
	return "users"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

模型常用标签

声明 model 时，tag 是可选的，GORM 支持以下 tag： tag 名大小写不敏感，但建议使用 camelCase 风格

主键

type User struct {
	Username string `gorm:"primaryKey"`                                                  
}
1
2
3

指定列明

默认情况以蛇形结构体字段名作为列明，但我们也可以通过tag指定

type User struct {
	Username string `gorm:"column：name"`                                                  
}
1
2
3

唯一约束

不可重复字段。

type User struct {
	Username string `gorm:"unique"`                                                  

1
2
3

列数据类型

推荐使用兼容性好的通用类型，例如：所有数据库都支持 bool、int、uint、float、string、time、bytes 并且可以和其他标签一起使用，例如：not null、size, autoIncrement… 像 varbinary(8) 这样指定数据库数据类型也是支持的。在使用指定数据库数据类型时，它需要是完整的数据库数据类型，如：MEDIUMINT UNSIGNED not NULL AUTO_INCREMENT

type User struct {
	ID   uint   `gorm:"type:int(11)"`
	Name string `gorm:"type:varchar(255)"`
	Age  int    `gorm:"type:tinyint"`
}
1
2
3
4
5

默认值

type User struct {
	Role string `gorm:"default:user"`
}
1
2
3

当结构体的字段默认值是零值的时候比如 0, ‘’, false，这些字段值将不会被保存到数据库中，你可以使用指针类型或者Scanner/Valuer来避免这种情况。例如：

type User struct {
  gorm.Model
  Name string
  Age  *int           `gorm:"default:18"`
  Active sql.NullBool `gorm:"default:true"`
}
1
2
3
4
5
6

指定字段数据类型长度大小

type User struct {
	Username string `gorm:"size:50"`
}
1
2
3

数据序列化或反序列化

type User struct {
	Settings map[string]interface{} `gorm:"serializer:json"`
}
1
2
3

serializer标签指定将Settings字段中的数据以JSON格式进行序列化和反序列化。

不能为空

type User struct {
	Settings map[string]interface{} `gorm:"not null"`
}
1
2
3

自增长

type User struct {
	ID uint `gorm:"primaryKey;autoIncrement"`
}
1
2
3

创建索引

type User struct {
	Email string `gorm:"index:idx_email"`
	Age   int    `gorm:"uniqueIndex:idx_age_country"`
}
1
2
3
4

在上述示例中，index标签创建名为idx_email的索引，uniqueIndex标签创建名为idx_age_country的唯一索引。

添加注释

type User struct {
	FirstName string `gorm:"comment:用户的名字"`
}
1
2
3

忽略字段

-标签表示忽略SecretField字段，即不进行数据库迁移和读写操作。

type User struct {
	SecretField string `gorm:"-"`
}
1
2
3

字段读写权限

<-:create表示只允许在创建时写入PasswordHash字段，->:false表示禁止读取PasswordHash字段。

type User struct {
	PasswordHash string `gorm:"<-:create;->:false"`
}
1
2
3

嵌入字段和嵌入字段列明前缀

type Address struct {
	City  string
	State string
}

type User struct {
	ID      uint
	Address Address `gorm:"embedded;embeddedPrefix:user_"`
}
1
2
3
4
5
6
7
8
9

embedded标签用于指定Address字段作为嵌套字段，embeddedPrefix标签用于指定嵌入字段的列名前缀为user_。相当于如下

type User struct {
	ID      uint
	City  string
	State string
}
//建表后字段名为ID  user_city user_state
1
2
3
4
5
6

关联标签

GORM中的关联标签通常用于指定如何处理模型之间的关联。 这些标签定义了一些关系细节，比如外键，引用和约束。

外键foreignKey

指定在关联表中使用的当前模型的列名作为外键。默认情况下，外键的名字，使用拥有者的类型名称加上表的主键的字段名字，对于如下的外键默认就是post_id

type User struct {
	ID       uint
	PostId int
	//foreignKey标签指定了在Post模型中使用UserID作为关联表的外键。
	Posts    []Post `gorm:"foreignKey:PostId"`
}

type Post struct {
	ID     uint
}
1
2
3
4
5
6
7
8
9
10

重写外键

默认情况下，外键的名字，使用拥有者的类型名称加上表的主键的字段名字。也就是company+id
例如：

type User struct {
	gorm.Model
	Name      string
	CompanyId int
	Company Company `gorm:"foreignKey:CompanyId"`
}
type Company struct {
	Name string
	Code int `gorm:"primaryKey"`
}
// 我们创建数据
func main() {
	global.GVA_DB = initialize.GormMysql()
	if global.GVA_DB != nil {
		initialize.TableInit()
	}
	c := model.Company{
		Name: "A公司",
		Code: 111,
	}
	u := model.User{
		Name:    "张三",
		Company: c,
	}
	u.CreateUser()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

结果如图所示：
我们可以将外键名字company_id名字改了，通过如下方式

type User struct {
	gorm.Model
	Name      string
	Company_FK int
	Company Company `gorm:"foreignKey:Company_FK "`
}
type Company struct {
	Name string
	Code int `gorm:"primaryKey"`
}
1
2
3
4
5
6
7
8
9
10

引用references

指定在关联表中外键对应的引用表的列名。

type User struct {
	ID       uint
	//references标签指定了Post模型中UserID外键对应的引用表的列名为ID。
	Posts    []Post `gorm:"foreignKey:UserID;references:ID"`
}

type Post struct {
	ID     uint
	UserID uint
}
1
2
3
4
5
6
7
8
9
10

重写引用

GORM 通常使用数据库表，主表（拥有者）的主键值作为外键参考。 正如上面的例子，我们使用主表Company中的主键字段ID作为外键的参考值。
但我们可以通过使用标签 references 来更改它。

type User struct {
	gorm.Model
	Name      string
	CompanyId int
	Company   Company `gorm:"foreignKey:CompanyId;references:Code"`
}

type Company struct {
	gorm.Model
	Name string
	Code int
}
// 我们创建数据
func main() {
	global.GVA_DB = initialize.GormMysql()
	if global.GVA_DB != nil {
		initialize.TableInit()
	}
	c := model.Company{
		Name: "A公司",
		Code: 111,
	}
	u := model.User{
		Name:    "张三",
		Company: c,
	}
	u.CreateUser()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

可以看结果引用不再是以公司主键ID作为外键值了。

多对多many2many

指定在多对多关系中使用的关联表。

type User struct {
	ID    uint
	//many2many标签指定了在User和Role之间使用的关联表为user_roles。
	Roles []Role `gorm:"many2many:user_roles;"`
}

type Role struct {
	ID   uint
	Name string
}
1
2
3
4
5
6
7
8
9
10

标识外键列joinForeignKey

标识在关联表中映射回当前模型的表的外键列。

type User struct {
	ID       uint
	//joinForeignKey标签指定了在关联表中映射回User模型的表的外键列为UserID。
	Posts    []Post `gorm:"many2many:user_posts;joinForeignKey:UserID;"`
}

type Post struct {
	ID     uint
	UserID uint
}
1
2
3
4
5
6
7
8
9
10

数据库相关操作

创建表CreateTable/AutoMigrate

一般我们使用AutoMigrate去创建
方式一

	err := db.AutoMigrate(
		models.Permission{},
		models.User{},
		models.Role{},
	)
1
2
3
4
5

方式二

	m := db.Migrator()
	m.CreateTable([]interface{}{&models.Permission{},&models.User{},&models.Role{},})
1
2

两种方式没太大差别

查询表HasTable

m := db.Migrator()
//传参结构体引用
m.HasTable(&models.User{})// 返回bool值
//传参字符串，这种硬编码方式不推荐
m.HasTable("user")// 返回bool值
1
2
3
4
5

删除表DropTable

	m := db.Migrator()
	exist_table := m.HasTable(&models.User{})
	if exist_table {
		m.CreateTable(&models.User{})
	}else{
		m.DropTable(&models.User{})
	}
1
2
3
4
5
6
7

修改表名

m := db.Migrator()
err := m.RenameTable(&models.User{},"yu_user")
1
2

关联关系

一对一

在 GORM 中，“Belongs To” 和 “Has One” 是两种不同的关联关系类型，用于定义数据库表之间的关系。它们之间的区别主要在于关联关系的方向和外键的存储位置。
在 Belongs To 关系中，外键通常存储在被关联模型（子模型）中。
在 Has One 关系中，外键通常存储在拥有模型（父模型）中。

属于关系Belongs To

属于关系是一方依赖于另一方，无法独立存在。
例如，假设我们有两个模型：Author（作者）和 Book（书籍）。一个 Book 属于一个 Author，因此我们可以在 Book 模型中定义一个 author_id 字段作为外键，用于存储与其关联的 Author 的主键。
下面省略建表步骤，只关注模型

package model

import "gorm.io/gorm"

// `User` 属于 `Company`，`CompanyID` 是外键 该外键存放在被关联的模型User中。
type User struct {
	gorm.Model
	Name      string
	CompanyID int
	Company   Company //如果设置了User实体属于Company实体，那么GORM会自动把Company中的ID属性保存到User的CompanyID属性中。默认情况下，外键的名字，使用拥有者的类型名称加上表的主键的字段名字
}

type Company struct {
	ID   int
	Name string
	Code string
}
func (this *User) CreateUser() {
	global.GVA_DB.Create(this)
}
func (this *Company) CreateCompany() {
	global.GVA_DB.Create(this)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

然后我们创建数据

package main

import (
	"fmt"
	"relation/global"
	"relation/initialize"
	"relation/model"
)

func main() {
	global.GVA_DB = initialize.GormMysql()
	if global.GVA_DB != nil {
		initialize.TableInit()
	}

	c := model.Company{
		Name: "A公司",
		Code: "AAA",
	}
	u := model.User{
		Name:    "张三",
		Company: c,
	}
	u.CreateUser()
	fmt.Println("数据库初始化成功")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

观察表

我们并没有创建公司的数据，但是通过GORM自动关联我们可以看到公司这个表自动被创建了。

拥有Has One

拥有关系是一方包含另一方，可以独立存在。
拥有Has One表明一个模型的每个实例都包含或拥有另一个模型的一个实例。如果我们假设一个 User拥有一个 CreditCard （个人资料），我们可以在 User 模型中定义一个 CreditCard 字段作为外键，用于存储与其关联的 CreditCard 的主键。

// User 有一张 CreditCard，UserID 是外键
type User struct {
  gorm.Model
  CreditCard CreditCard
}

type CreditCard struct {
  gorm.Model
  Number string
  UserID uint
}
1
2
3
4
5
6
7
8
9
10
11

一对多

不同于 has one，拥有者可以有零或多个关联模型。例如，每个 user 可以有多张 credit card。多的一方把另一方的主键作为外键。少的一方声明多的一方的数组切片类型。
一对多在多的一方存放外键

// User 有多张 CreditCard，UserID 是外键
type User struct {
  gorm.Model
  CreditCards []CreditCard
}

type CreditCard struct {
  gorm.Model
  Number string
  UserID uint
}
1
2
3
4
5
6
7
8
9
10
11

查询

// 检索用户列表并预加载信用卡
func GetAll(db *gorm.DB) ([]User, error) {
    var users []User
    err := db.Model(&User{}).Preload("CreditCards").Find(&users).Error
    return users, err
}
1
2
3
4
5
6

自引用

自己引用自己

type User struct {
  gorm.Model
  Name      string
  ManagerID *uint
  Team      []User `gorm:"foreignkey:ManagerID"`
}
1
2
3
4
5
6

多对多

多对多需要中间表，在gorm中需要用关联标签，展示出关系。

// User 拥有并属于多种 language，`user_languages` 是连接表
type User struct {
	gorm.Model
	Name      string
	Languages []Language `gorm:"many2many:user_languages;"`
}

type Language struct {
	gorm.Model
	Name string
}
1
2
3
4
5
6
7
8
9
10
11

我们创建几个数据

	global.GVA_DB.Create([]model.User{
		model.User{
			Name: "张三",
			Languages: []model.Language{
				model.Language{
					Name: "英语",
				},
				model.Language{
					Name: "汉语",
				},
			},
		},
		model.User{
			Name: "李四",
			Languages: []model.Language{
				model.Language{
					Name: "德语",
				},
				model.Language{
					Name: "俄语",
				},
			},
		},
	})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

观察表，

反向引用

在上面创建表插入数据后，我们查询语言，看结果

var l []model.Language
global.GVA_DB.Select("name").Find(&l)
fmt.Println(l)
1
2
3

如果我们想查询语言关联的用户呢？

// 检索 Language 列表并预加载 User
func GetAllLanguages() ([]model.Language, error) {
	var languages []model.Language
	err := global.GVA_DB.Model(&model.Language{}).Preload("Users").Find(&languages).Error
	return languages, err
}
1
2
3
4
5
6

此时会报错。
这时候我们需要反向引用，才能够在查询语言时预加载用户。那怎么反向引用呢？我们需要给Language表加上用户的引用，如下

type User struct {
	gorm.Model
	Name      string
	Languages []Language `gorm:"many2many:user_languages;"`
}

type Language struct {
	gorm.Model
	Name string
	Users []*User `gorm:"many2many:user_languages;"`
}
1
2
3
4
5
6
7
8
9
10
11

此时再执行上面的查询操作GetAllLanguages

就可以成功拿到结果了。
总结一下：选择哪种方式取决于具体的业务需求，如果需要在查询Language模型时方便地访问与之关联的User模型的数据，可以选择第二种方式。否则，如果只需要在查询User模型时访问与之关联的Language模型的数据，第一种方式已经足够。

重写外键

对于 many2many 关系，连接表会同时拥有两个模型的外键，例如：

type User struct {
  gorm.Model
  Languages []Language `gorm:"many2many:user_languages;"`
}

type Language struct {
  gorm.Model
  Name string
}

// 连接表：user_languages
//   foreign key: user_id, reference: users.id
//   foreign key: language_id, reference: languages.id
1
2
3
4
5
6
7
8
9
10
11
12
13

重写外键

type User struct {
	gorm.Model
	Name      string
	Languages []Language `gorm:"many2many:user_language;foreignKey:Refer;References:LRefer;joinForeignKey:u_id;joinReferences:p_id"`
	Refer     uint
}

type Language struct {
	gorm.Model
	Name   string
	LRefer uint
}
1
2
3
4
5
6
7
8
9
10
11
12

foreignKey:Refer：指定连接表中指向User模型的外键字段名为Refer的字段，且外键名字改为user_refer,默认是user_id(表名+主键字段名)。
joinForeignKey:UserReferID：改本表外键名。
References:UserRefer：指定连接表中指向Profile模型的外键字段名为LRefer的字段，且外键名改为language_l_refer(表名+主键字段名)。
joinReferences:ProfileRefer：改连接表外键名。

自定义中间表

type Person struct {
  ID        int
  Name      string
  Addresses []Address `gorm:"many2many:person_addresses;"`
}

type Address struct {
  ID   uint
  Name string
}

type PersonAddress struct {
  PersonID  int `gorm:"primaryKey"`
  AddressID int `gorm:"primaryKey"`
  CreatedAt time.Time
  DeletedAt gorm.DeletedAt
}

func (PersonAddress) BeforeCreate(db *gorm.DB) error {
  // ...
}

// 修改 Person 的 Addresses 字段的连接表为 PersonAddress
// PersonAddress 必须定义好所需的外键，否则会报错
err := db.SetupJoinTable(&Person{}, "Addresses", &PersonAddress{})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

表相关操作

排除和指定字段

通过select指定字段，如下是创建指定字段数据

	u := model.User{
		Name: "张三",
		Age:  18,
	}
	global.GVA_DB.Select("Age").Create(&u)
1
2
3
4
5

通过omit排除指定字段

var h model.Human
global.GVA_DB.Omit("name").Find(&h)
1
2

这样就得到了除了name字段以外的值。

增

type User struct {
	gorm.Model
	Name string
	Age int
	Birthday time.Time
}
user := User{Name: "Jinzhu", Age: 18, Birthday: time.Now()}

result := db.Create(&user) // 通过数据的指针来创建

user.ID             // 返回插入数据的主键
result.Error        // 返回 error
result.RowsAffected // 返回插入记录的条数
1
2
3
4
5
6
7
8
9
10
11
12
13

新增多条记录

方式一

users := []User{
    User{Name: "Jinzhu", Age: 18, Birthday: time.Now()},
    User{Name: "Jackson", Age: 19, Birthday: time.Now()},
}

result := db.Create(&users) // 传递切片以插入多行数据

	u1 := model.User{
		Name:     "张三",
		Age:      18,
		Birthday: time.Now(),
		UserInfo: ui,
		Company:  c,
	}
	u2 := model.User{
		Name:     "李四",
		Age:      27,
		Birthday: time.Now(),
		UserInfo: ui,
		Company:  c,
	}
	global.GVA_DB.Create([]*model.User{&u1, &u2})

result.Error        // 返回 error
result.RowsAffected // 返回插入记录的条数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

方式二CreateBatchSize
使用CreateBatchSize 选项初始化GORM实例后，此后进行创建& 关联操作时所有的INSERT行为都会遵循初始化时的配置。

var users = []model.User{{Name: "jinzhu_1", Birthday: time.Now()}, {Name: "jinzhu_2", Birthday: time.Now()}, {Name: "jinzhu_10000", Birthday: time.Now()}}
global.GVA_DB.CreateInBatches(users, len(users))
1
2

sqlite批量插入不支持默认值

SQLite 不支持批量插入的时候使用默认值。解决方案：通过BeforeCreate钩子设置

func (p *Pet) BeforeCreate(tx *gorm.DB) (err error) {
    if p.Name == "" {
        p.Name = "cat"
    }
}
1
2
3
4
5

创建的声明周期钩子

GROM允许用户通过实现这些接口 BeforeSave, BeforeCreate, AfterSave, AfterCreate来自定义钩子。 这些钩子方法会在创建一条记录时被调用，关于钩子的生命周期请参阅Hooks。

func (u *User) BeforeCreate(tx *gorm.DB) (err error) {
  u.UUID = uuid.New()

    if u.Role == "admin" {
        return errors.New("invalid role")
    }
    return
}
1
2
3
4
5
6
7
8

如果想跳过Hooks方法，可以使用SkipHooks会话模式，例子如下

DB.Session(&gorm.Session{SkipHooks: true}).Create(&user)

DB.Session(&gorm.Session{SkipHooks: true}).Create(&users)

DB.Session(&gorm.Session{SkipHooks: true}).CreateInBatches(users, 100)

1
2
3
4
5
6

根据Map创建

创建记录不仅只有结构体的方式还能通过map创建，但不用的是**当使用map来创建时，钩子方法不会执行，关联不会被保存且不会回写主键。**因此最好使用结构体创记录。

db.Model(&User{}).Create([]map[string]interface{}{
  {"Name": "jinzhu_1", "Age": 18},
  {"Name": "jinzhu_2", "Age": 20},
})
1
2
3
4

关联创建

创建关联数据时，如果关联值非零，这些关联会被更新插入，并且它们的Hooks方法也会被调用。

type UserInfo struct {
	gorm.Model
	Address string
	Email   string
	IPhone  string
	UserId  uint
}
type User struct {
	gorm.Model
	Name     string
	Age      int8
	Birthday time.Time
	UserInfo  UserInfo
}
	ui := model.UserInfo{
		Address: "中国",
		Email:   "xxx@qq.com",
		IPhone:  "1234567",
	}
	u := model.User{
		Name:     "张三",
		Age:      18,
		Birthday: time.Now(),
		UserInfo: ui,
	}

	global.GVA_DB.Create(&u)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

跳过关联更新

可以通过Select, Omit方法来跳过关联更新，示例如下：

db.Omit("UserInfo").Create(&user)

// skip all associations
db.Omit(clause.Associations).Create(&user)
1
2
3
4

删除

改

查

preload预加载查询

模型

type UserInfo struct {
	gorm.Model
	Address string
	Email   string
	IPhone  string
	UserId  uint
}
type User struct {
	gorm.Model
	Name      string
	Age       int8
	Birthday  time.Time
	CompanyId int
	Company   Company `gorm:"foreignKey:CompanyId;references:Code"`
	UserInfo  UserInfo
}
type Company struct {
	gorm.Model
	Name string
	Code int
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

创建数据

	c := model.Company{
		Name: "A公司",
		Code: 111,
	}
	ui := model.UserInfo{
		Address: "中国",
		Email:   "xxx@qq.com",
		IPhone:  "1234567",
	}
	u1 := model.User{
		Name:     "张三",
		Age:      18,
		Birthday: time.Now(),
		UserInfo: ui,
		Company:  c,
	}
	u2 := model.User{
		Name:     "李四",
		Age:      27,
		Birthday: time.Now(),
		UserInfo: ui,
		Company:  c,
	}
	global.GVA_DB.Create([]*model.User{&u1, &u2})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

查询

	var u model.User
	global.GVA_DB.Select("name", "age").First(&u)
	fmt.Println(u)//此时查询结果
1
2
3

此时查询结果并没有关联表信息，如果需要查询关联表信息需要preload
preload查询

	var u model.User
	global.GVA_DB.Preload("UserInfo").Preload("Company").First(&u)
	fmt.Println(u)
1
2
3

preload后面除了预加载的表还可以跟查询条件

	var u model.User
	global.GVA_DB.Preload("UserInfo"，"address=中国").Preload("Company").First(&u)
	fmt.Println(u)
	//高级查询
		global.GVA_DB.Preload("UserInfo"，func(db *gorm.DB)*gorm.DB{
			return db.Joins("XXX").Where("xxx")
		}).Preload("Company").First(&u)
	
1
2
3
4
5
6
7
8

单个记录查询

GORM 提供了 First、Take、Last 方法，以便从数据库中检索单个对象。当查询数据库时它添加了 LIMIT 1 条件，且没有找到记录时，它会返回 ErrRecordNotFound 错误

// 获取第一条记录（主键升序）
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;

result := db.First(&user)
result.RowsAffected // 返回找到的记录数
result.Error        // returns error or nil

// 检查 ErrRecordNotFound 错误
errors.Is(result.Error, gorm.ErrRecordNotFound)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

如果你想避免ErrRecordNotFound错误，你可以使用Find，比如db.Limit(1).Find(&user).对单个对象使用Find而不带limit，db.Find(&user)将会查询整个表并且只返回第一个对象，这是性能不高并且不确定的。

查询全部记录

var users_res []model.User
global.GVA_DB.Debug().Find(&users_res)
fmt.Println(users_res)
// SELECT * FROM `user` WHERE `user`.`deleted_at` IS NULL

result.RowsAffected // returns found records count, equals `len(users)`
result.Error        // returns error
1
2
3
4
5
6
7

条件查询

根据主键查询。

（使用字符串时，需要额外的注意来避免SQL注入）

db.First(&user, 10)
// SELECT * FROM users WHERE id = 10;
db.Find(&users, []int{1,2,3})
// SELECT * FROM users WHERE id IN (1,2,3);
1
2
3
4

字符串条件

db.Where("name = ?", "jinzhu").First(&user)
// SELECT * FROM users WHERE name = 'jinzhu' ORDER BY id LIMIT 1;
查找name != jinzhu的
db.Where("name <> ?", "jinzhu").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 >= ?", "jinzhu", "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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

结构体、Map和切片条件查询

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

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

// Slice of primary keys
db.Where([]int64{20, 21, 22}).Find(&users)
// SELECT * FROM users WHERE id IN (20, 21, 22);
1
2
3
4
5
6
7
8
9
10
11

当使用结构体查询Gorm只会查询非零值字段（0,‘’,fasle），

db.Where(&User{Name: "jinzhu", Age: 0}).Find(&users)
// SELECT * FROM users WHERE name = "jinzhu";
1
2

如果查询条件中包含零值就使用Map查询

db.Where(map[string]interface{}{"Name": "jinzhu", "Age": 0}).Find(&users)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 0;
1
2

find内联查询

// Get by primary key if it were a non-integer type
db.First(&user, "id = ?", "string_primary_key")
// SELECT * FROM users WHERE id = 'string_primary_key';
// ===如下
db.Where("id=?","string_primary_key").find(&user)

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

db.Find(&users, "name <> ? AND age > ?", "jinzhu", 20)
// SELECT * FROM users WHERE name <> "jinzhu" AND age > 20;
// ===如下
db.Where("name <> ? AND age > ?","jinzhu", 20).find(&user)

// Struct
db.Find(&users, User{Age: 20})
// SELECT * FROM users WHERE age = 20;
// ===如下
db.Where("age=?, 20).find(&user)

// Map
db.Find(&users, map[string]interface{}{"age": 20})
// SELECT * FROM users WHERE age = 20;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Not查询DB.Not( )

db.Not("name = ?", "jinzhu").First(&user)
// SELECT * FROM users WHERE NOT name = "jinzhu" ORDER BY id LIMIT 1;

// Not In
db.Not(map[string]interface{}{"name": []string{"jinzhu", "jinzhu 2"}}).Find(&users)
// SELECT * FROM users WHERE name NOT IN ("jinzhu", "jinzhu 2");

// Struct
db.Not(User{Name: "jinzhu", Age: 18}).First(&user)
// SELECT * FROM users WHERE name <> "jinzhu" AND age <> 18 ORDER BY id LIMIT 1;

// Not In slice of primary keys
db.Not([]int64{1,2,3}).First(&user)
// SELECT * FROM users WHERE id NOT IN (1,2,3) ORDER BY id LIMIT 1;
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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 = 'jinzhu'").Or(User{Name: "jinzhu 2", Age: 18}).Find(&users)
// SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);

// Map
db.Where("name = 'jinzhu'").Or(map[string]interface{}{"name": "jinzhu 2", "age": 18}).Find(&users)
// SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);
1
2
3
4
5
6
7
8
9
10

查询记录的特定字段

db.Select("name", "age").Find(&users)
// SELECT name, age FROM users;

db.Select([]string{"name", "age"}).Find(&users)
// SELECT name, age FROM users;

db.Table("users").Select("COALESCE(age,?)", 42).Rows()
// SELECT COALESCE(age,'42') FROM users;
1
2
3
4
5
6
7
8

排序查询DB.Order( )

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

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

db.Clauses(clause.OrderBy{
  Expression: clause.Expr{SQL: "FIELD(id,?)", Vars: []interface{}{[]int{1, 2, 3}}, WithoutParentheses: true},
}).Find(&User{})
// SELECT * FROM users ORDER BY FIELD(id,1,2,3)
1
2
3
4
5
6
7
8
9
10
11

偏移量limit 和offset

limit指定要检索的最大记录数 Offset指定在开始返回记录之前要跳过的记录数

db.Limit(10).Offset(5).Find(&users)
// SELECT * FROM users OFFSET 5 LIMIT 10;
1
2

去重Distinct

db.Distinct("name", "age").Order("name, age desc").Find(&results)

1
2

joins查询

type result struct {
  Name  string
  Email string
}

db.Model(&User{}).Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&result{})
// SELECT users.name, emails.email FROM `users` left join emails on emails.user_id = users.id

rows, err := db.Table("users").Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Rows()
for rows.Next() {
  ...
}

db.Table("users").Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&results)

// multiple joins with parameter
db.Joins("JOIN emails ON emails.user_id = users.id AND emails.email = ?", "jinzhu@example.org").Joins("JOIN credit_cards ON credit_cards.user_id = users.id").Where("credit_cards.number = ?", "411111111111").Find(&user)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

多态

在GORM中为一对多和多对多关系提供了多态支持。
什么是多态呢？同一类型不同表现形态。具体一点举个场景例子，有一个Human表和Animal表，还有一个tool工具表。我们想在Human和Tool表之间建立一对多或多对多关系以及Animal和tool表之间同样建立一对一或一对多关系。假设一对多，我不总不能在tool表中建立HumanId外键和AnimalId外键吧？那如果后面又加一个Alia的表需要和tool建立关系，难道要再加一个AliaId字段吗？
综上所述，我们可以在主表中添加如下关联标签

type Human struct {
  ID   int
  Name string
  Tool []Tool`gorm:"polymorphic:Owner;"`
}
type Tool struct {
  ID        int
  Name      string
  OwnerID   int
  OwnerType string
}
1
2
3
4
5
6
7
8
9
10
11

然后执行下面语句添加点数据

db.Create(&Human {Name: "Human1", Tool: []Tool{{Name: "Tool1"}, {Name: "Tool2"}}})
db.Create(&model.Animal{Name: "Animal1", Tool: []model.Tool{{Name: "Tool1"}, {Name: "Tool2"}}})
1
2

观察数据库Tool

多态的关联标签

`gorm:"polymorphic:Owner;polymorphicValue:master"`
1

polymorphic：根据上面我们能看出来polymorphic字段其实就是指定多态字段的名字的。还用上面例子，我们把tool的polymorphic修改成PolymorphicOwner，并在tool中添加多态字段，看结果

type Human struct {
	ID   int
	Name string
	Tool []Tool `gorm:"polymorphic:PolymorphicOwner;"`
}
type Tool struct {
	ID                   int
	Name                 string
	PolymorphicOwnerID   int
	PolymorphicOwnerType string
}
type Animal struct {
	ID   int
	Name string
	Tool []Tool `gorm:"polymorphic:PolymorphicOwner;"`
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

polymorphicValue就是更改多态字段的值，我们添加如下标签看结果。

type Human struct {
	ID   int
	Name string
	Tool []Tool `gorm:"polymorphic:PolymorphicOwner;polymorphicValue:PhTool"`
}
type Tool struct {
	ID                   int
	Name                 string
	PolymorphicOwnerID   int
	PolymorphicOwnerType string
}
type Animal struct {
	ID   int
	Name string
	Tool []Tool `gorm:"polymorphic:PolymorphicOwner;polymorphicValue:PhTool"`
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

利用Error.is判断错误

我们可以利用Error.is判断gorm报错信息，根据这个信息执行相应操作，例如

if !errors.Is(db.Where("username = ?", u.Username).First(&user).Error, gorm.ErrRecordNotFound) { // 判断用户名是否注册
	return userInter, errors.New("用户名已注册")
}

assignErr := global.GVA_DB.Where("user_id = ? AND authority_authority_id = ?", id, authorityId).First(&system.SysUserAuthority{}).Error
	if errors.Is(assignErr, gorm.ErrRecordNotFound) {
		return errors.New("该用户无此角色")
	}
1
2
3
4
5
6
7
8

事务

事务就是要么成功要么全部回滚。

开启事务

db.Transaction(func(tx *gorm.DB) error {
  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
})
1
2
3
4
5
6
7
8
9
10
11
12
13

嵌套事务

凡是调用db.Transaction的返回Error的事务内部全部回滚。

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(tx3 *gorm.DB) error {
    tx3.Create(&user3)
    return nil
  })

  return nil
})

// Commit user1, user3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

手动执行事务

db, _ := GLOV_DB.DB()
// 开始事务
tx := db.Begin()

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

// ...

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

// 否则，提交事务
tx.Commit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

示例

func CreateAnimals(db *gorm.DB) error {
  //事务一旦开始，使用 tx 处理数据
  tx := db.Begin()
  defer func() {
    if r := recover(); r != nil {
      tx.Rollback()
    }
  }()

  if err := tx.Error; err != nil {
    return err
  }

  if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
     tx.Rollback()
     return err
  }

  if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
     tx.Rollback()
     return err
  }

  return tx.Commit().Error
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

事务保存点

有时候我们希望事务失败回滚时，不要回滚全部任务，从我们指定位置回滚，就可以使用保存点，然后回滚至保存点。
示例：

func CreateAnimals(db *gorm.DB) error {
  tx := db.Begin()
  defer func() {
    if r := recover(); r != nil {
      tx.RollbackTo("sp1")
    }
  }()
  if err := tx.Error; err != nil {
    return err
  }
  tx.Create(&user1)
  tx.SavePoint("sp1")
  tx.Create(&user2)
  return tx.Commit().Error
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

自定义数据类型

什么是自定义数据类型？有些类型的数据，无法直接存到数据库，例如结构体，map，这些数据不向string int等可以直接存，那怎么办呢？这就需要自定义数据类型。
自定义的数据类型必须实现 Scanner 和 Valuer 接口，以便让 GORM 知道如何将该类型接收、保存到数据库，Valuer让GORM知道如何存数据，Scanner让GORM知道如何取出来数据。
示例：

type user_info struct {
	Name string
	Age  int
}
type User struct {
	gorm.Model
	Info user_info
}
db.AutoMigrate(&model.User{})
1
2
3
4
5
6
7
8
9

自定义数据类型：

type User_info struct {
	Name string
	Age  int
}
type User struct {
	gorm.Model
	Info User_info
}

func (this User_info) Value() (driver.Value, error) {
	str, err := json.Marshal(this)
	if err != nil {
		return nil, err
	}
	return string(str), nil
}
func (this *User_info) Scan(value interface{}) error {
	obj, ok := value.([]byte)
	if !ok {
		return errors.New("不匹配")
	}
	json.Unmarshal(obj, this)
	return nil
}
	global.GVA_DB.AutoMigrate(&model.User{})
	global.GVA_DB.Create(&model.User{
		Info: model.User_info{Name: "info_name", Age: 18},
	})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

查询一下

	var u model.User
	global.GVA_DB.Find(&u)
	fmt.Println(u)
1
2
3