gin gorm gormV2
一、gorm介绍
参考地址： https://gorm.io/zh_CN/docs/index.html
安装包
go get -u gorm.io/gorm
go get -u gorm.io/driver/sqlite
二、连接到数据库
1、gorm 连接mysql数据库
https://gorm.io/zh_CN/docs/gorm_config.html
数据库连接
**注意：**想要正确的处理 time.Time ，您需要带上 parseTime 参数， (更多参数) 要支持完整的 UTF-8 编码，您需要将 charset=utf8 更改为 charset=utf8mb4 查看 此文章 获取详情
db, err := gorm.Open(mysql.New(mysql.Config{
DSN: "root:ts123456@tcp(127.0.0.1:3306)/my_gormv2?charset=utf8mb4&parseTime=True&loc=Local",
DefaultStringSize: 256, // string 类型字段的默认长度
}), &gorm.Config{
// https://gorm.io/zh_CN/docs/gorm_config.html
SkipDefaultTransaction: false, // 跳过默认事务, GORM 会在事务里执行写入操作（创建、更新、删除）。如果没有这方面的要求，您可以在初始化时禁用它
NamingStrategy: schema.NamingStrategy{ // 表名命名策略
TablePrefix: "t_", // 表名前缀，`User`表为`t_users`
SingularTable: true, // 使用单数表名，启用该选项后，`User` 表将是`t_user`
},
DryRun: false, // 生成 SQL 但不执行，可以用于准备或测试生成的 SQL
DisableForeignKeyConstraintWhenMigrating: true, // 在 AutoMigrate 或 CreateTable 时，GORM 会自动创建外键约束，若要禁用该特性，可将其设置为 true
})
链接池
https://gorm.io/zh_CN/docs/connecting_to_the_database.html#%E8%BF%9E%E6%8E%A5%E6%B1%A0
// GORM 使用 database/sql 维护连接池
sqlDB, _ := db.DB()
sqlDB.SetMaxIdleConns(10) // SetMaxIdleConns 设置空闲连接池中连接的最大数量
sqlDB.SetMaxOpenConns(100) // SetMaxOpenConns 设置打开数据库连接的最大数量
sqlDB.SetConnMaxLifetime(time.Hour) // SetConnMaxLifetime 设置了连接可复用的最大时间
完整内容
import (
"gorm.io/driver/mysql"
"gorm.io/gorm"
"gorm.io/gorm/schema"
"time"
)
// 定义全局变量
var GLOBAL_DB *gorm.DB
func main() {
db, _ := gorm.Open(mysql.New(mysql.Config{
DSN: "root:ts123456@tcp(127.0.0.1:3306)/my_gormv2?charset=utf8mb4&parseTime=True&loc=Local",
}), &gorm.Config{
// https://gorm.io/zh_CN/docs/gorm_config.html
SkipDefaultTransaction: false, // 跳过默认事务, GORM 会在事务里执行写入操作（创建、更新、删除）。如果没有这方面的要求，您可以在初始化时禁用它
NamingStrategy: schema.NamingStrategy{ // 表名命名策略
//TablePrefix: "t_", // 表名前缀，`User`表为`t_users`
SingularTable: true, // 使用单数表名，启用该选项后，`User` 表将是`t_user`
},
DryRun: false, // 生成 SQL 但不执行，可以用于准备或测试生成的 SQL
DisableForeignKeyConstraintWhenMigrating: true, // 在 AutoMigrate 或 CreateTable 时，GORM 会自动创建外键约束，若要禁用该特性，可将其设置为 true
})
// GORM 使用 database/sql 维护连接池
sqlDB, _ := db.DB()
sqlDB.SetMaxIdleConns(10) // SetMaxIdleConns 设置空闲连接池中连接的最大数量
sqlDB.SetMaxOpenConns(100) // SetMaxOpenConns 设置打开数据库连接的最大数量
sqlDB.SetConnMaxLifetime(time.Hour) // SetConnMaxLifetime 设置了连接可复用的最大时间
GLOBAL_DB = db // 把 db 赋值
// https://gorm.io/zh_CN/docs/migration.html
// AutoMigrate 用于自动迁移表
//db.AutoMigrate(&User{})
// 如果存在表则删除（删除时会忽略、删除外键约束)
//M.DropTable(&User{})
}
表迁移
https://gorm.io/zh_CN/docs/migration.html
type User struct {
Name string
Age int
}
// https://gorm.io/zh_CN/docs/migration.html
// AutoMigrate 用于自动迁移表
//db.AutoMigrate(&User{})
// 迁移表
M := db.Migrator()
M.CreateTable(&User{}) // 创建表
// 如果存在表则删除（删除时会忽略、删除外键约束)
//M.DropTable(&User{})
// 检查 `User` 对应的表是否存在
fmt.Println(M.HasTable(&User{}))
2、模型
https://gorm.io/zh_CN/docs/models.html
模型是标准的 struct，由 Go 的基本数据类型、实现了 Scanner 和 Valuer 接口的自定义类型及其指针或别名组成
GORM 倾向于约定，而不是配置。默认情况下，GORM 使用 ID 作为主键，使用结构体名的 蛇形复数 作为表名，字段名的 蛇形 作为列名，并使用 CreatedAt、UpdatedAt 字段追踪创建、更新时间
-
GORM 定义一个
gorm.Model结构体// gorm.Model 的定义 type Model struct { UUID uint `gorm:"primaryKey"` CreatedAt time.Time UpdatedAt time.Time DeletedAt gorm.DeletedAt `gorm:"index"` } -
将它嵌入到结构体中
type TestUser struct { Model Model `gorm:"embedded"` Name string Email *string Age uint8 Birthday *time.Time MemberNumber sql.NullString ActivatedAt sql.NullTime } -
字段标签
声明model时，tag 是可选的
-
column : 列名称
-
primaryKey : 列为主键
-
unique : 列为唯一
-
default ： 指定列的默认值
-
not null : 指定列不允许为空
-
embedded : 嵌套字段
-
embeddedPrefix：嵌套字段的列名前缀
-
index : 指定索引
-
uniqeIndex : 唯一索引
-
comment : 注释，数据库字段描述
-
precision : 精度（浮点型）
-
size : 列大小
示例
type TestUser struct { Model Model `gorm:"embedded"` Name string `gorm:"comment:姓名"` Email *string `gorm:"column:my_email;comment:邮箱"` } -
三、gorm简单增删改查
1、创建数据
https://gorm.io/zh_CN/docs/create.html
创建数据
user := TestUser{Name: "vic", Age: 20}
result := GLOBAL_DB.Create(&user) // 通过指针来创建数据
// 返回 error, 影响的条数
fmt.Println(result.Error, "=======", result.RowsAffected)
指定字段创建数据
user := TestUser{Name: "vic", Age: 22}
// 用 Select 指定的字段创建
result := GLOBAL_DB.Select("age").Create(&user) // 通过指针来创建数据
// 返回 error, 影响的条数
fmt.Println(result.Error, "=======", result.RowsAffected)
创建一个记录且一同忽略传递要略去的字段值
user := TestUser{Name: "ccg", Age: 22}
// 用 Omit 指定的字段创建
result := GLOBAL_DB.Omit("age").Create(&user) // 通过指针来创建数据
// 返回 error, 影响的条数
fmt.Println(result.Error, "=======", result.RowsAffected)
批量插入数据
利用数组，将一个 slice 传递给 Create 方法
users := []TestUser{
{Name: "C1", Age: 22},
{Name: "C2", Age: 22},
{Name: "C3", Age: 22},
}
// 批量插入数据
result := GLOBAL_DB.Create(&users) // 通过指针来创建数据
// 返回 error, 影响的条数
fmt.Println(result.Error, "=======", result.RowsAffected)
2、查询数据
https://gorm.io/zh_CN/docs/query.html
检索单个对象
// 获取第一条记录（主键升序）,
// 方式一： 目标 struct 是指针
var ret1 TestUser
GLOBAL_DB.First(&ret1)
fmt.Println(ret1)
// 方式二：通过 `db.Model()` 指定了 model
ret2 := map[string]interface{}{}
GLOBAL_DB.Model(&TestUser{}).First(&ret2)
fmt.Println(ret2)
用主键检索
// 主键检索数据
// 主键是数字类型
//SELECT * FROM users WHERE uuid = 5;
var user1 TestUser
GLOBAL_DB.First(&user1, 5)
fmt.Println(user1)
// 把返回的数据拿出来，增加判断
var User TestUser
dbRes := GLOBAL_DB.First(&User, 5)
fmt.Println(dbRes.Error) // 返回结果 record not found
fmt.Println(errors.Is(dbRes.Error,gorm.ErrRecordNotFound)) // dbRes.Error 查询返回的错误，gorm.ErrRecordNotFound 系统gorm 返回的错误，结果返回 true；通过判断查询是否成功，然后再进行下一步操作
//主键是字符串
var user2 TestUser
GLOBAL_DB.First(&user2, "name = ?", "C2")
fmt.Println(user2)
检索全部数据
// 检索全部数据, 使用切片接收返回结果
var users []TestUser
GLOBAL_DB.Find(&users)
fmt.Println(users)
String条件
// 获取第一条匹配的记录
var user TestUser
// 忽略不想显示的字段
GLOBAL_DB.Omit("created_at", "updated_at").Where("name = ?", "vic").First(&user)
fmt.Println(user)
// 获取 LIKE 匹配的所有记录
// SELECT * FROM users WHERE name LIKE '%g%';
var users []TestUser
GLOBAL_DB.Where("name LIKE ?", "%g%").Find(&users)
fmt.Println("LIKE: ", users)
// AND
var U1 []TestUser
GLOBAL_DB.Where("name = ? AND age >= ?", "ccg", "21").Find(&U1)
fmt.Println("AND: ", U1)
Struct & Map
// Struct
// SELECT * FROM users WHERE name = "jinzhu" AND age = 20 ORDER BY id LIMIT 1;
var user TestUser
GLOBAL_DB.Where(&TestUser{Name: "ccg", Age: 21}).First(&user)
fmt.Println("Struct: ", user)
// Map
// SELECT * FROM users WHERE name = "jinzhu" AND age = 20;
users := map[string]interface{}{}
GLOBAL_DB.Model(&TestUser{}).Where(map[string]interface{}{"name": "B2", "age": 23}).Find(&users)
fmt.Println("Map: ", users)
3、更新数据
https://gorm.io/zh_CN/docs/update.html
Update 更新单列
// Update 更新单个列
// 当使用了 Model 方法，且该对象主键有值
GLOBAL_DB.Model(&TestUser{}).Where("age = ?", 21).Update("name", "A2")
// 根据条件和 model 的值进行更新
var users TestUser
GLOBAL_DB.Model(&users).Where("name = ?", "vic").Update("age", 18)
Save 保存所有字段
// Save 会保存所有的字段，即使字段是零值
// 更新查询的第一条数据
var user TestUser
GLOBAL_DB.First(&user)
user.Name = "CC"
user.Age = 100
GLOBAL_DB.Save(&user)
// 批量更新符合条件的列
var users []TestUser
dbRes := GLOBAL_DB.Where("name LIKE ?", "%2%").Find(&users)
for k := range users {
users[k].Age = 30
}
dbRes.Save(&users)
Updates 更新所有字段 — 常用
// Updates 更新所有字段 struct 和 map[string]interface{} 参数,
// Struct 更新时，GORM 只会更新非零字段
var user TestUser
GLOBAL_DB.First(&user).Updates(TestUser{Name: "AA", Age: 222})
// 如果您想确保指定字段被更新，你应该使用 Select 更新选定字段，或使用 map 来完成更新操作
GLOBAL_DB.First(&user).Updates(map[string]interface{}{"name": "A5", "age": 222})
// 批量更新
// Struct
GLOBAL_DB.Where(&TestUser{}).Where("name = ?", "A2").Updates(TestUser{Age: 55, Address: "北京"})
// 根据 map 更新
GLOBAL_DB.Table("test_user").Where("age IN ?", []int{22, 30}).Updates(map[string]interface{}{"address": "上海"})
4、删除数据
https://gorm.io/zh_CN/docs/delete.html
// 如果您的模型包含了一个 gorm.DeletedAt 字段（gorm.Model 已经包含了该字段)，它将自动获得软删除的能力！
// 拥有软删除能力的模型调用 Delete 时，记录不会被从数据库中真正删除。但 GORM 会将 DeletedAt 置为当前时间， 并且你不能再通过正常的查询方法找到该记录。
// 根据主键删除，可以使用数字，字符串
GLOBAL_DB.Delete(&TestUser{}, 2)
GLOBAL_DB.Delete(&TestUser{}, "5")
GLOBAL_DB.Delete(&TestUser{}, []int{1, 3, 4})
// 批量删除
// 如果指定的值不包括主属性，那么 GORM 会执行批量删除
GLOBAL_DB.Where("name LIKE ?", "%g%").Delete(TestUser{})
// 另一种写法
GLOBAL_DB.Where(TestUser{}, "name LIKE ?", "%g%").Delete(TestUser{})
// 永久删除
GLOBAL_DB.Unscoped().Delete(&TestUser{}, 10)
5、原生SQL
// https://gorm.io/zh_CN/docs/sql_builder.html#%E5%8E%9F%E7%94%9F-SQL
type Result struct {
ID int
Name string
Age int
}
var result Result
db.Raw("SELECT id, name, age FROM users WHERE name = ?", 3).Scan(&result)
db.Raw("SELECT id, name, age FROM users WHERE name = ?", 3).Scan(&result)
var age int
db.Raw("SELECT SUM(age) FROM users WHERE role = ?", "admin").Scan(&age)
var users []User
db.Raw("UPDATE users SET name = ? WHERE age = ? RETURNING id, name", "jinzhu", 20).Scan(&users)
四、数据关联
1、Belongs to
belongs to 创建的每一个实例都 “属于” 另一个模型的一个实例
示例结构体 https://gorm.io/zh_CN/docs/belongs_to.html
// User 属于 Company，CompanyID 是关联外键，并且每个 User 能且只能被分配一个 Company,
type User struct { // 用户
gorm.Model
Name string `gorm:"unique"`
CompanyID uint
Company Company
}
type Company struct { // 公司
gorm.Model
Name string
}
基本操作
// 创建数据库, 自动创建属于表 Company
//GLOBAL_DB.AutoMigrate(&User{})
// 创建数据
// 创建两家 Company
C1 := Company{
Name: "百度",
}
C2 := Company{
Model: gorm.Model{ID: 2},
Name: "新浪",
}
GLOBAL_DB.Create(&C1)
GLOBAL_DB.Create(&C2)
// 创建用户
// 根据已有的ID进行管理
U1 := User{
Name: "Vic",
CompanyID: 1,
}
GLOBAL_DB.Create(&U1)
// 创建数据，自动关联
C3 := Company{
Name: "拼多多",
}
U2 := User{
Name: "ccg",
Company: C3,
}
GLOBAL_DB.Create(&U2)
// 查询
var company Company
GLOBAL_DB.First(&company, 2)
fmt.Println("查询：", company)
预加载 https://gorm.io/zh_CN/docs/preload.html
GORM 运行通过 Preload 或者 Joins 来主动加载实体的关联关系
// Preload 预加载
var puser User
GLOBAL_DB.Preload("Company").First(&puser, 1)
fmt.Println("Preload预加载查询：", puser)
// Jions
var juser User
GLOBAL_DB.Joins("Company").First(&juser, 2)
fmt.Println("Joins预加载查询：", juser)
Belongs to 的 CURD 使用关联模式进行操作
https://gorm.io/zh_CN/docs/associations.html#%E5%85%B3%E8%81%94%E6%A8%A1%E5%BC%8F
// 关联模式
/*
判断是否下面的二个要求，符合会开始关联模式，否则返回错误
1. user 是源模型，主键不能为空，
2. 关系的字段名称是 Company
*/
var user User
err := GLOBAL_DB.Model(&user).Association("Company").Error
if err != nil {
fmt.Println("该数据没有关联：", err)
}
// 添加关联, 前提表中数据已经存在
u1 := User{
Model: Model{UUID: 3},
}
c1 := Company{Model: Model{UUID: 4}}
GLOBAL_DB.Model(&u1).Association("Company").Append(&c1)
// 替换关联
u2 := User{
Model: Model{
UUID: 2,
},
}
c4 := Company{
Model: Model{
UUID: 4,
},
}
c7 := Company{
Model: Model{
UUID: 7,
},
}
GLOBAL_DB.Model(&u2).Association("Company").Replace(&c4, &c7)
// 删除源模型与关联之间的所有引用
u1 := User{
Model: Model{
UUID: 1,
},
}
GLOBAL_DB.Model(&u1).Association("Company").Clear()
2、Has One
https://gorm.io/zh_CN/docs/has_one.html
基础数据
// Has one 与另外一个模型建立一对一的关联，这种关联表明一个模型的每个实例都包涵或拥有另一个模型的实例
// 每个 User1 只能有一张 Card ,User1 有一张 Caed，UserID 是外键
type User1 struct {
Model
Name string
Card Card
}
type Card struct {
Model
Number string
User1ID uint
}
添加数据
执行预加载
//创建数据库
//GLOBAL_DB.AutoMigrate(&User1{}, &Card{})
// 添加数据
/*
u11 := User1{
Name: "u11",
}
u22 := User1{
Name: "u22",
}
c11 := Card{
Number: "11111",
User1ID: 1,
}
c22 := Card{
Number: "2222",
User1ID: 2,
}
GLOBAL_DB.Create(&u11)
GLOBAL_DB.Create(&u22)
GLOBAL_DB.Create(&c11)
GLOBAL_DB.Create(&c22)
*/
// 查询
var card Card
GLOBAL_DB.First(&card)
fmt.Println(card)
// 预加载
// Preload 预加载
var puser1 User1
GLOBAL_DB.Preload("Card").Find(&puser1, 2)
fmt.Println("Preload预加载查询：", puser1)
// Jions 预加载
var juser1 User1
GLOBAL_DB.Joins("Card").Find(&juser1, 1)
fmt.Println("Joins预加载查询：", juser1)
Has one 的 CURD 使用关联模式进行操作
// 添加关联，前提数据已经在数据库存在
c33 := Card{
Model: Model{
UUID: 3,
},
}
u33 := User1{
Model: Model{
UUID: 3,
},
}
// 添加关联
GLOBAL_DB.Model(&u33).Association("Card").Append(&c33)
// 替换关联
u11 := User1{
Model: Model{
UUID: 1,
},
}
c11 := Card{
Model: Model{
UUID: 1,
},
}
c22 := Card{
Model: Model{
UUID: 2,
},
}
GLOBAL_DB.Model(&u11).Association("Card").Replace(&c11, &c22)
// 删除关联
GLOBAL_DB.Model(&u11).Association("Card").Delete(&u11)
// 清空关联
GLOBAL_DB.Model(&u11).Association("Card").Clear()
3、Has Many
https://gorm.io/zh_CN/docs/has_many.html
has many与另一个模型建立了一对多的连接。 不同于has one，拥有者可以有零或多个关联模型
创建模型
// 声明 teacher 和 class 模型，且每个 class 可以有多个 teacher
type Class struct { // 班级
Model
Name string
Teachers []Teacher
}
type Teacher struct { // 教师
Model
name string
ClassID uint
}
// 创建数据库，
//GLOBAL_DB.AutoMigrate(&Class{}, &Teacher{})
添加数据
// 添加数据
// 创建二个 Teacher
T1 := Teacher{
Name: "英语老师",
}
T2 := Teacher{
Name: "法语老师",
}
// 创建一个 class, 里面包涵二个 teacher
C1 := Class{
Name: "初中一年级",
Teachers: []Teacher{T1, T2},
}
//使用Create 方法创建
GLOBAL_DB.Create(&C1)
数据查询
https://gorm.io/zh_CN/docs/preload.html
// 查询, 只查询到 class，没有查询到包涵的 teacher
var class Class
GLOBAL_DB.First(&class)
fmt.Println(class)
// 使用 Preload 预加载的模式, 查询关联的 teacher
var class Class
GLOBAL_DB.Preload("Teachers").First(&class)
fmt.Println(class)
// Grom 运行使用带条件的Preload, 查询包涵 英语老师
var class Class
GLOBAL_DB.Preload("Teachers", "name = ?", "英语老师").First(&class)
fmt.Println(class)
// 可以通过 func(db *gorm.DB) *gorm.DB 实现自定义预加载 SQL
var class Class
GLOBAL_DB.Preload("Teachers", func(db *gorm.DB) *gorm.DB {
return db.Where("name = ?", "法语老师")
}).First(&class)
fmt.Println(class)
嵌套预加载
https://gorm.io/zh_CN/docs/preload.html#%E5%B5%8C%E5%A5%97%E9%A2%84%E5%8A%A0%E8%BD%BD
// 增加 Info 模型，和 Teacher 属于 一对一关系
type Info struct {
Model
Money int
TeacherID uint
}
type Teacher struct { // 教师
Model
Name string
ClassID uint
Info Info
}
查询数据
var class Class
GLOBAL_DB.Preload("Teachers.Info").First(&class)
fmt.Println(class)
// 只查询包涵 英语老师
var class Class
GLOBAL_DB.Preload("Teachers.Info").Preload("Teachers", "name = ?", "英语老师").First(&class)
fmt.Println(class)
// 注意：Preload 带条件的预加载查询，只适用于查询当前的预加载语句，如果查询 money > 200 的结果就会报错,返回所有
var class Class
GLOBAL_DB.Preload("Teachers.Info", "money > 200").Preload("Teachers").First(&class)
fmt.Println(class)
使用joins 关联查询解决上述问题
joins Preload 适用于一对一的关系，例如 has one，belongs to
// 使用 joins Preload 查询数据
var class Class
GLOBAL_DB.Preload("Teachers", func(db *gorm.DB) *gorm.DB {
return db.Joins("Info")
}).First(&class)
fmt.Println(class)
// 使用 joins 查询实现 money > 200 的 teacher
var class Class
GLOBAL_DB.Preload("Teachers", func(db *gorm.DB) *gorm.DB {
return db.Joins("Info").Where("money > 200")
}).First(&class)
fmt.Println(class)
4、Many To Many
https://gorm.io/zh_CN/docs/many_to_many.html
many to Many 会在二个 model 中添加一张链接表
Model 模型
// 创建模型 user 和 address ，一个 user 可以包含多个address； 多个user可以属于一种 address，user包含 info,has one 关系
type InfoR struct {
Model
Money int
PeopleID uint
}
type People struct {
Model
Name string
InfoR InfoR
Addresses []Address `gorm:"many2many:people_address;"`
}
type Address struct {
Model
Name string
Peoples []People `gorm:"many2many:people_address;"`
}
GLOBAL_DB.AutoMigrate(&InfoR{}, &People{}, &Address{})
添加数据
// 添加数据
i1 := Infos{
Money: 2000,
}
a1 := Address{
Name: "北京市",
}
a2 := Address{
Name: "上海市",
}
p := People{
Name: "王小二",
Infos: i1,
Addresses: []Address{a1, a2},
}
// 添加数据, 指定address UUID
i2 := Infos{
Money: 1000,
}
a1 := Address{
Model: Model{
UUID: 1,
},
Name: "北京市",
}
a2 := Address{
Model: Model{
UUID: 2,
},
Name: "上海市",
}
p := People{
Name: "王小三",
Infos: i2,
Addresses: []Address{a1, a2},
}
GLOBAL_DB.Create(&p)
数据查询
// 查询 UUID 为 1 的 people, 没有查询出address 和 infos
p := People{
Model: Model{
UUID: 1,
},
}
GLOBAL_DB.Find(&p)
fmt.Println(p)
// 使用关联模式查询, 只查询出来了 address
var address []Address
GLOBAL_DB.Model(&p).Association("Addresses").Find(&address)
fmt.Println(address)
// 查询出来了 address, 结果想把 people也带上，使用 Preload
GLOBAL_DB.Model(&p).Preload("Peoples").Association("Addresses").Find(&address)
fmt.Println(address)
// 查询出 address people，结果把 infos结果也带着, 使用 Preload joins
GLOBAL_DB.Model(&p).Preload("Peoples", func(db *gorm.DB) *gorm.DB {
return db.Joins("Infos")
}).Association("Addresses").Find(&address)
fmt.Println(address)
// 只带出 money > 1500
GLOBAL_DB.Model(&p).Preload("Peoples", func(db *gorm.DB) *gorm.DB {
return db.Joins("Infos").Where("money > 1500")
}).Association("Addresses").Find(&address)
fmt.Println(address)
五、多态关联
https://gorm.io/zh_CN/docs/has_many.html#%E5%A4%9A%E6%80%81%E5%85%B3%E8%81%94
Gorm 为 has one和 has many 提供了多态关联支持。它会将拥有者实体的表名、主键都保存到多态类型的字段中
`gorm:"polymorphic:Owner;polymorphicValue:master"`
- polymorphic：指定多态类型（结构体上面的那个标签名，固定写法；Owner 值对应 OwnerID(和实体者的主键类型相同)、OwnerType ）
- polymorphicValue：指定多态的值，自定义字段的名称（数据库里用来记录是哪个结构体的哪个字段的值）
- 多态的结构体的数据不可以同时被多人拥有
模型示例
// Cat 实体
type Cat struct {
Model
Name string
Toy Toy `gorm:"polymorphic:Owner;polymorphicValue:CatToy"`
}
/*
Dog 实体，多态不可以被多个实体同时拥有，但是可以一个实体对应多个多态
polymorphic: Owner 对应 多态的 OwnerID、OwnerType 前缀名称，类型和主键类型保持一致;
polymorphicValue:DogToy 设置多态类型的值，一般设置成主键的名称和多态名
*/
type Dog struct {
Model
Name string
Toy []Toy `gorm:"polymorphic:Owner;polymorphicValue:DogToy"`
}
// Toy 多态实体
type Toy struct {
Model
Name string
OwnerID uint
OwnerType string
}
表结构
- cat 表结构
| uuid | name |
|---|---|
- dog 表结构
| uuid | name |
|---|---|
- Toy 多态表结构
| uuid | name | owner_id | owner_type |
|---|---|---|---|
添加数据
GLOBAL_DB.Create(&Cat{Name: "小黑猫", Toy: Toy{Name: "小老鼠"}})
GLOBAL_DB.Create(&Dog{Name: "小黑狗", Toy: []Toy{
{Name: "小骨头"},
{Name: "大骨头"},
}})
数据库表数据
- cat 表结构
| uuid | name |
|---|---|
| 1 | 小黑猫 |
- dog 表结构
| uuid | name |
|---|---|
| 1 | 小黑狗 |
- Toy 多态表结构
| uuid | name | owner_id | owner_type |
|---|---|---|---|
| 1 | 小老鼠 | 1 | CatToy |
| 2 | 小骨头 | 1 | DogToy |
| 3 | 大骨头 | 1 | DogToy |
六、关联模式
https://gorm.io/zh_CN/docs/associations.html
-
foreignKey：指定当前模型的列作为连接表的外键，即指定外键以自己的哪个key去关联
-
references：指定引用表名的列名，其将被映射为连接表的外键，指定引用被关联结果的那个key
-
joinForeignKey：指定连接表的外键列名，其将被映射到当前表
-
joinReferences：指定连接表的外键列表，其将别映射到引用表
1、has many
示例代码
package main
/*
Zoo 实体
foreignKey:ZooName 指向连接表(Monkey)的外键的key(Monkey的ZooName列名)
references:Name 引用本结构体的列名(Zoo的Name列名)，被映射为连接表的外键名称
*/
type Zoo struct {
Model
Name string
Monkey []Monkey `gorm:"foreignKey:ZooName;references:Name"`
}
// Monkey 实体
type Monkey struct {
Model
Name string
ZooName string
}
func Foreign() {
// 创建表
GLOBAL_DB.AutoMigrate(&Monkey{}, &Zoo{})
// 增加数据
GLOBAL_DB.Create(&Zoo{
Name: "北京动物园",
Monkey: []Monkey{
{Name: "小黑猴"},
{Name: "小白猴"},
}})
}
数据库表内容
Zoo 表
| uuid | name |
|---|---|
| 1 | 北京动物园 |
Monkey 表
| uuid | name | zoo_name |
|---|---|---|
| 1 | 小黑猴 | 北京动物园 |
| 2 | 小白猴 | 北京动物园 |
2、Many2Many
代码示例
package main
/*
Zoo 实体
注意： 某些数据库只允许在唯一索引字段上创建外键，如果您在迁移时会创建外键，则需要指定 unique index 标签。
many2many:zoo_monkey 中间关联表
foreignKey:Name 指向本表的主键列名(Zoo的Name)
joinForeignKey:ZooName 重写中间表关联本表的列名
references:Name 指向关联表的主键列名(Monkey 的 Name)
joinReferences:MonkeyName 重写中间表关联的关联表的列名
*/
type Zoo struct {
Model
Name string `gorm:"primaryKey"`
Monkey []Monkey `gorm:"many2many:zoo_monkey;foreignKey:Name;joinForeignKey:ZooName;References:Name;joinReferences:MonkeyName"`
}
// Monkey 实体
type Monkey struct {
Model
Name string `gorm:"primaryKey"`
}
func Foreign() {
// 创建表
GLOBAL_DB.AutoMigrate(&Zoo{}, &Monkey{})
// 增加数据
GLOBAL_DB.Create(&Zoo{
Name: "北京动物园",
Monkey: []Monkey{
{Name: "小黑猴"},
{Name: "小白猴"},
}})
}
数据库表内容
zoo
| uuid | name |
|---|---|
| 1 | 北京动物园 |
monkey
| uuid | name |
|---|---|
| 1 | 小黑猴 |
| 2 | 小白猴 |
zoo_monkey
| zoo_name | monkey_name |
|---|---|
| 北京动物园 | 小黑猴 |
| 北京动物园 | 小白猴 |
七、事务
https://gorm.io/zh_CN/docs/transactions.html
为了确保数据一致性，GORM 会在事务里执行写入操作（创建、更新、删除）。如果没有这方面的要求，您可以在初始化时禁用它，这将获得大约 30%+ 性能提升。
// 全局禁用
db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{
SkipDefaultTransaction: true,
})
1、基础事务
package main
import "gorm.io/gorm"
// Ts 结构体
type Ts struct {
Model
Name string `gorm:"unique"`
}
func Transaction() {
// 创建表
GLOBAL_DB.AutoMigrate(&Ts{})
// 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'）
GLOBAL_DB.Transaction(func(tx *gorm.DB) error {
if err := tx.Create(&Ts{Name: "事务一"}).Error; err != nil {
// 返回任何错误都会回滚事务，即不执行此事务
return err
}
if err := tx.Create(&Ts{Name: "事务二"}).Error; err != nil {
// 返回任何错误都会回滚事务，即不执行此事务
return err
}
/*
// 因为指定了 Name 列为名为唯一值，如果开启下面的事务，则上面的二条事务不会执行
if err := tx.Create(&Ts{Name: "事务一"}).Error; err != nil {
// 返回任何错误都会回滚事务，即不执行此事务
return err
}
*/
// 返回 nil 提交事务
return nil
})
}
2、嵌套事务
package main
import "gorm.io/gorm"
// Ts 结构体
type Ts struct {
Model
Name string `gorm:"unique"`
}
func Transaction() {
GLOBAL_DB.AutoMigrate(&Ts{})
// 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'）
GLOBAL_DB.Transaction(func(tx *gorm.DB) error {
if err := tx.Create(&Ts{Name: "事务一"}).Error; err != nil {
// 返回任何错误都会回滚事务，即不执行此事务
return err
}
// GORM 支持嵌套事务, 可以回滚较大事务内执行的一部分操作
tx.Transaction(func(tx *gorm.DB) error {
if err := tx.Create(&Ts{Name: "事务二"}).Error; err != nil {
return err
}
// 因为指定了 Name 列为名为唯一值，如果开启下面的事务，列名重复会报错，则此嵌套里面的事务都不会执行
err := tx.Create(&Ts{Name: "事务一"})
if err != nil {
return err.Error
}
// 返回 nil 提交事务
return nil
})
// 返回 nil 提交事务
return nil
})
}
3、手动事务
Gorm 支持直接调用事务控制方法（commit、rollback）
package main
// Ts 结构体
type Ts struct {
Model
Name string `gorm:"unique"`
}
func Transaction() {
GLOBAL_DB.AutoMigrate(&Ts{})
// 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'）
// 开始事务
tx := GLOBAL_DB.Begin()
// 执行 数据库操作
tx.Create(&Ts{Name: "事务一"})
tx.Create(&Ts{Name: "事务二"})
tx.Create(&Ts{Name: "事务一"})
// 遇到错误时回滚事务; 上面Name是唯一值，出现了多次 事务一 ，所以回滚上面的事务，即不执行
tx.Rollback()
// 提交事务
tx.Commit()
}
SavePoint、Rollbackto
GORM 提供了 SavePoint、Rollbackto 方法，来提供保存点以及回滚至保存点功能
tx := db.Begin()
tx.Create(&user1)
tx.SavePoint("sp1")
tx.Create(&user2)
tx.RollbackTo("sp1") // Rollback user2
tx.Commit() // Commit user1
八、自定义数据类型
GORM 提供了少量接口，使用户能够为 GORM 定义支持的数据类型
1、json示例
package main
import (
"database/sql/driver"
"encoding/json"
"errors"
"fmt"
)
// CInfo 定义一个数据类型
type CInfo struct {
Sex string
Age int
}
// CUser 实体类引用定义的（CInfo）类型
type CUser struct {
Model
Name string
Info CInfo
}
// Value 实现 driver.Value 接口，Value 返回 json value ；存数据用
func (c CInfo) Value() (driver.Value, error) {
// 把数据加工成 json
str, err := json.Marshal(c)
if err != nil {
return nil, err
}
// 并返回 string 类型的数据
return string(str), nil
}
// Scan 实现 sql.Scanner 接口, 渲染出 value 的值；查数据用
func (c *CInfo) Scan(value interface{}) error {
// 接收value的值，利用类型断言判断值是否为 字节类型
str, ok := value.([]byte)
if !ok {
return errors.New(fmt.Sprint("数据类型不匹配"))
}
// 断言成功，把结果渲染到 c 指针上面
json.Unmarshal(str, c)
return nil
}
func CustomType() {
// 创建数据库
GLOBAL_DB.AutoMigrate(&CUser{})
/*
// 添加数据
GLOBAL_DB.Create(&CUser{
Name: "王小二",
Info: CInfo{
Sex: "男",
Age: 20,
}})
*/
// 查询数据
var c CUser
GLOBAL_DB.First(&c)
fmt.Println(c)
}
2、数组示例
package main
import (
"database/sql/driver"
"encoding/json"
"errors"
"fmt"
"strings"
)
// CInfo 定义一个数据类型
type CInfo struct {
Sex string
Age int
}
// Args 定义数组类型
type Args []string
// CUser 实体类引用定义的（CInfo）类型
type CUser struct {
Model
Name string
Info CInfo // 使用自定义的 CInfo 类型
Address Args // 使用自定义的 Args 类型
}
// Value 实现 driver.Value 接口，Value 返回 json value ；存json数据用
func (c CInfo) Value() (driver.Value, error) {
// 把数据加工成 json
str, err := json.Marshal(c)
if err != nil {
return nil, err
}
// 并返回 string 类型的数据
return string(str), nil
}
// Scan 实现 sql.Scanner 接口, 渲染出 value 的值；查Json数据用
func (c *CInfo) Scan(value interface{}) error {
// 接收value的值，利用类型断言判断值是否为 字节类型
str, ok := value.([]byte)
if !ok {
return errors.New(fmt.Sprint("数据类型不匹配"))
}
// 断言成功，把结果渲染到 c 指针上面
json.Unmarshal(str, c)
return nil
}
// Value 实现 driver.Value 接口，Value 返回 json value ；存数组数据用
func (a Args) Value() (driver.Value, error) {
// 判断数组的长度
if len(a) > 0 {
// 有数据，就进行数组的拼接
var str string = a[0]
for _, v := range a[1:] {
// 循环拼接 str 字符串
str += "," + v
}
return str, nil
} else {
// 没有数据就存 空
return "", nil
}
}
// Scan 实现 sql.Scanner 接口, 渲染出 value 的值；查 数组数据用
func (a *Args) Scan(value interface{}) error {
// 接收value的值，利用类型断言判断值是否为 字节类型
str, ok := value.([]byte)
if !ok {
return errors.New(fmt.Sprint("数据类型不匹配"))
}
// 断言成功，把结果渲染到 a 指针上面, 利用strings的字符串分割 str的值 返回原始的结果
*a = strings.Split(string(str), ",")
return nil
}
func CustomType() {
// 创建数据库
GLOBAL_DB.AutoMigrate(&CUser{})
// 添加数据
GLOBAL_DB.Create(&CUser{
Name: "王小二",
Info: CInfo{
Sex: "男",
Age: 20,
},
Address: Args{
"北京市",
"上海市",
"杭州市",
},
})
// 查询数据
var c CUser
GLOBAL_DB.First(&c)
fmt.Println(c)
}