上一次已经介绍了 Gorm 的大致如何使用,本次我们将详细了解 Gorm 中相关的知识点。
模型定义
在 Gorm 中,模型是一种用于描述数据库表结构的代码形式。模型通常是一个 Go 结构体,其中的每个字段都代表了数据库表的一个列。
如果我们想要操作数据库需要预先定义模型。底层都是使用的 golang 的 database 标准库,利用反射原理,执行读写操作时,将结构体翻译为 sql 语句,并将结果转化为对应的模型。
模型定义
首先创建一个商品表。
CREATE TABLE `goods` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增ID,商品Id',
`name` varchar(30) NOT NULL COMMENT '商品名',
`price` decimal(10,2) unsigned NOT NULL COMMENT '商品价格',
`type_id` int(10) unsigned NOT NULL COMMENT '商品类型Id',
`createtime` int(10) NOT NULL DEFAULT 0 COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
将对应的表结构转换为模型后,如下:
type Good struct {
Id int //表字段名为:id
Name string //表字段名为:name
Price float64 //表字段名为:price
TypeId int //表字段名为:type_id
CreateTime int64 `gorm:"column:createtime"` //表字段名为:createtime
}
默认 gorm 对 struct 字段名使用Snake Case命名风格转换成 mysql 表字段名(需要转换成小写字母)。
Snake Case命名风格,就是各个单词之间用下划线(_)分隔,例如: CreateTime的Snake Case风格命名为create_time。
同时默认情况下,使用ID
做为其主键,使用结构体名称的Snake Case
风格的复数形式做为表名,使用 CreatedAt
、UpdatedAt
字段追踪创建、更新时间。
模型标签
标签定义:
`gorm:"标签内容"`
标签定义部分,多个标签定义可以使用分号(;)分隔
gorm 常用标签如下:
标签 | 说明 | 例子 |
---|---|---|
column | 指定列名 | gorm:"column:createtime" |
primaryKey | 指定主键 | gorm:"column:id; PRIMARY_KEY" |
- | 忽略字段 | gorm:"-" 可以忽略struct字段,被忽略的字段不参与gorm的读写操作 |
其他的可以查看官方文档:https://gorm.io/zh_CN/docs/models.html#embedded_struct
表名映射
复数表名,比如结构体
User
,默认的表名为users
实现 Tabler 接口 (
TableName
不支持动态变化,它会被缓存下来以便后续使用。)
type Tabler interface {
TableName() string
}
// TableName 会将 User 的表名重写为 `profiles`
func (User) TableName() string {
return "profiles"
}
- 动态表名,使用 Scopes
func UserTable(user User) func (tx *gorm.DB) *gorm.DB {
return func (tx *gorm.DB) *gorm.DB {
if user.Admin {
return tx.Table("admin_users")
}
return tx.Table("users")
}
}
db.Scopes(UserTable(user)).Create(&user)
- 临时表名
db.Table("deleted_users")
Model
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"`
}
GORM 约定使用 CreatedAt
、UpdatedAt
追踪创建/更新时间。如果定义了这种字段,GORM 在创建、更新时会自动填充当前时间。
要使用不同名称的字段,您可以配置 autoCreateTime、autoUpdateTime 标签。
如果想要保存 UNIX(毫/纳)秒时间戳,而不是 time,只需简单地将 time.Time 修改为 int 即可。
例子:
type User struct {
CreatedAt time.Time // 默认创建时间字段, 在创建时,如果该字段值为零值,则使用当前时间填充
UpdatedAt int // 默认更新时间字段, 在创建时该字段值为零值或者在更新时,使用当前时间戳秒数填充
Updated int64 `gorm:"autoUpdateTime:nano"` // 自定义字段, 使用时间戳填纳秒数充更新时间
Updated int64 `gorm:"autoUpdateTime:milli"` //自定义字段, 使用时间戳毫秒数填充更新时间
Created int64 `gorm:"autoCreateTime"` //自定义字段, 使用时间戳秒数填充创建时间
}
可以将它嵌入到您的结构体中,以包含这几个字段,比如
type User struct {
gorm.Model
Name string
}
// 等效于
type User struct {
ID uint `gorm:"primaryKey"`
CreatedAt time.Time
UpdatedAt time.Time
DeletedAt gorm.DeletedAt `gorm:"index"`
Name string
}
对于正常的结构体字段,你也可以通过标签 embedded
将其嵌入,例如:
type Author struct {
Name string
Email string
}
type Blog struct {
ID int
Author Author `gorm:"embedded"`
Upvotes int32
}
// 等效于
type Blog struct {
ID int64
Name string
Email string
Upvotes int32
}
可以使用标签 embeddedPrefix
来为 db 中的字段名添加前缀,例如:
type Blog struct {
ID int
Author Author `gorm:"embedded;embeddedPrefix:author_"`
Upvotes int32
}
// 等效于
type Blog struct {
ID int64
AuthorName string
AuthorEmail string
Upvotes int32
}
数据库连接
GORM 官方支持的数据库类型有: MySQL, PostgreSQL, SQlite, SQL Server。
连接数据库主要是两个步骤:
- 配置 DSN (Data Source Name)
- 使用 gorm.Open 连接数据库
DSN
gorm 库使用 dsn 作为连接数据库的参数,dsn 翻译过来就叫数据源名称,用来描述数据库连接信息。一般都包含数据库连接地址,账号,密码之类的信息。
格式:
[username[:password]@][protocol[(address)]]/dbname[?param1=value1&...¶mN=valueN]
mysql 的 dsn 的一些例子:
//mysql dsn格式
//涉及参数:
//username 数据库账号
//password 数据库密码
//host 数据库连接地址,可以是Ip或者域名
//port 数据库端口
//Dbname 数据库名
username:password@tcp(host:port)/Dbname?charset=utf8&parseTime=True&loc=Local
//填上参数后的例子
//username = root
//password = 123456
//host = localhost
//port = 3306
//Dbname = gorm
//后面K/V键值对参数含义为:
// charset=utf8 客户端字符集为utf8
// parseTime=true 支持把数据库datetime和date类型转换为golang的time.Time类型
// loc=Local 使用系统本地时区
root:123456@tcp(localhost:3306)/gorm?charset=utf8&parseTime=True&loc=Local
//gorm 设置mysql连接超时参数
//开发的时候经常需要设置数据库连接超时参数,gorm是通过dsn的timeout参数配置
//例如,设置10秒后连接超时,timeout=10s
//下面是完成的例子
root:123456@tcp(localhost:3306)/gorm?charset=utf8&parseTime=True&loc=Local&timeout=10s
//设置读写超时时间
// readTimeout - 读超时时间,0代表不限制
// writeTimeout - 写超时时间,0代表不限制
root:123456@tcp(localhost:3306)/gorm?charset=utf8&parseTime=True&loc=Local&timeout=10s&readTimeout=30s&writeTimeout=60s
要支持完整的 UTF-8 编码,需要将 charset=utf8
更改为 charset=utf8mb4
。
连接数据库
import (
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
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{})
}
MySQL 驱动程序提供了 一些高级配置 可以在初始化过程中使用,例如:
db, err := gorm.Open(mysql.New(mysql.Config{
DSN: "gorm:gorm@tcp(127.0.0.1:3306)/gorm?charset=utf8&parseTime=True&loc=Local", // 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{})
GORM 允许通过 DriverName
选项自定义 MySQL 驱动,例如:
import (
_ "example.com/my_mysql_driver"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
db, err := gorm.Open(mysql.New(mysql.Config{
DriverName: "my_mysql_driver",
DSN: "gorm:gorm@tcp(localhost:9910)/gorm?charset=utf8&parseTime=True&loc=Local", // data source name, 详情参考:https://github.com/go-sql-driver/mysql#dsn-data-source-name
}), &gorm.Config{})
调试模式
db.Debug()
连接池配置
sqlDB, _ := db.DB()
//设置数据库连接池参数
sqlDB.SetMaxOpenConns(100) //设置数据库连接池最大连接数
sqlDB.SetMaxIdleConns(20) //连接池最大允许的空闲连接数,如果没有sql任务需要执行的连接数大于20,超过的连接会被连接池关闭
增删改查
插入数据
user := User{
Username:"zhangsan",
Password:"123456",
CreateTime:time.Now().Unix(),
}
db.Create(&user)
user.ID // 返回插入数据的主键
result.Error // 返回 error
result.RowsAffected // 返回插入记录的条数
用指定的字段创建:
db.Select("username","password").Create(&user)
忽略字段
db.Omit("username").Create(&user)
批量插入:
var users = []User{{Username: "jinzhu1"}, {Username: "jinzhu2"}, {Username: "jinzhu3"}}
db.Create(&users)
for _, user := range users {
user.ID // 1,2,3
}
使用 CreateInBatches
分批创建时,你可以指定每批的数量,例如:
var users = []User{{Username: "jinzhu_1"}, ...., {Username: "jinzhu_10000"}}
// 数量为 100
db.CreateInBatches(users, 100)
使用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},
})
map创建注意,主键不会被填充。
sql表达式:
DB.Model(&User{}).Create(map[string]interface{}{
"username": "jinzhu",
"password": clause.Expr{SQL: "md5(?)", Vars: []interface{}{"123456"}},
})
使用原生sql语句:
db.Exec("insert into users (username,password,createtime) values (?,?,?)", user.Username, user.Password, user.CreateTime)
更新数据
在创建一个表
CREATE TABLE `goods` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '商品id',
`title` varchar(100) NOT NULL COMMENT '商品名',
`price` decimal(10, 2) NULL DEFAULT 0.00 COMMENT '商品价格',
`stock` int(11) DEFAULT '0' COMMENT '商品库存',
`type` int(11) DEFAULT '0' COMMENT '商品类型',
`create_time` datetime NOT NULL COMMENT '商品创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
package dao
import "time"
type Goods struct {
Id int
Title string
Price float64
Stock int
Type int
CreateTime time.Time
}
func (v Goods) TableName() string {
return "goods"
}
func SaveGoods(goods Goods) {
DB.Create(&goods)
}
package dao
import (
"testing"
"time"
)
func TestSaveGoods(t *testing.T) {
goods := Goods{
Title: "毛巾",
Price: 25,
Stock: 100,
Type: 0,
CreateTime: time.Now(),
}
SaveGoods(goods)
}
保存数据
goods := Goods{}
DB.Where("id = ?", 1).Take(&goods)
goods.Price = 100
//UPDATE `goods` SET `title`='毛巾',`price`=100.000000,`stock`=100,`type`=0,`create_time `='2022-11-25 13:03:48' WHERE `id` = 1
DB.Save(&goods)
更新单个列
goods := Goods{}
DB.Where("id = ?", 2).Take(&goods)
DB.Model(&goods).Update("title", "hello")
更新多列
goods := Goods{}
DB.Where("id = ?", 2).Take(&goods)
//更新非零值的字段 也可以使用map
DB.Model(&goods).Updates(Goods{
Title: "hello",
Stock: 200,
})
更新选定的字段
goods := Goods{}
DB.Where("id = ?", 2).Take(&goods)
DB.Model(&goods).Select("title").Updates(Goods{
Title: "hello",
Stock: 200,
})
排除:
goods := Goods{}
DB.Where("id = ?", 2).Take(&goods)
DB.Model(&goods).Omit("title").Updates(Goods{
Title: "hello",
Stock: 200,
})
也可以组合使用
Select("*").Omit("title")
gorm更新必须带条件进行更新,否则会返回错误gorm.ErrMissingWhereClause
,或者启用 AllowGlobalUpdate
模式
db.Session(&gorm.Session{AllowGlobalUpdate: true}).Model(&User{}).Update("name", "jinzhu")
表达式
db.Model(&goods).Update("stock", gorm.Expr("stock + 1"))
db.Model(&goods).Update(map[string]interface{}{"stock": gorm.Expr("stock + 1")})
子查询更新
goods := Goods{}
DB.Where("id = ?", 2).Take(&goods)
DB.Model(&goods).Update("title", DB.Model(&User{}).Select("username").Where("id=?", 2))
删除数据
goods := Goods{}
DB.Where("id = ?", 2).Take(&goods)
DB.Delete(&goods)
//根据主键删除
DB.Delete(&Goods{}, 1)
同样的道理,不带条件不能进行删除,必须加一些条件,或者使用原生 SQL,或者启用 AllowGlobalUpdate
模式
db.Session(&gorm.Session{AllowGlobalUpdate: true}).Delete(&User{})
// DELETE FROM users
查询数据
查询函数
Take:查询一条记录
db.Take(&goods)
First: 根据主键正序排序后,查询第一条数据
db.First(&goods)
Last:根据主键倒序排序后,查询最后一条记录
db.Last(&goods)
Find:查询多条记录
db.Find(&goods)
Pluck:查询一列值
var titles []string db.Model(&Goods{}).Pluck("title", &titles)
当 First、Last、Take 方法找不到记录时,GORM 会返回 ErrRecordNotFound 错误,可以通过对比gorm.ErrRecordNotFound
进行判断,或者使用Find和Limit的组合进行查询。
db.Limit(1).Find(&user)
where
通过db.Where函数设置条件
函数说明:
db.Where(query interface{}, args ...interface{})
参数说明:
参数名 | 说明 |
---|---|
query | sql语句的where子句, where子句中使用问号(?)代替参数值,则表示通过args参数绑定参数 |
args | where子句绑定的参数,可以绑定多个参数 |
比如:
db.Where("id in (?)", []int{1,2,5,6}).Take(&goods)
select
设置select子句, 指定返回的字段
var goods Goods
DB.Select("id", "title").Find(&goods)
也可以写聚合函数
var total int
DB.Model(&Goods{}).Select("count(*) as total").Pluck("total", &total)
fmt.Println(total)
order
排序
var goods []Goods
DB.Order("id desc").Find(&goods)
分页
通过 limit
和 Offset
实现
var goods []Goods
DB.Order("create_time desc").Limit(10).Offset(10).Find(&goods)
count
返回查询匹配的行数
var total int64 = 0
DB.Model(Goods{}).Count(&total)
fmt.Println(total)
分组
//统计每个商品分类下面有多少个商品
//定一个Result结构体类型,用来保存查询结果
type Result struct {
Type int
Total int
}
var results []Result
//等价于: SELECT type, count(*) as total FROM `goods` GROUP BY type HAVING (total > 0)
db.Model(Goods{}).Select("type, count(*) as total").Group("type").Having("total > 0").Scan(&results)
//scan类似Find都是用于执行查询语句,然后把查询结果赋值给结构体变量,区别在于scan不会从传递进来的结构体变量提取表名.
//这里因为我们重新定义了一个结构体用于保存结果,但是这个结构体并没有绑定goods表,所以这里只能使用scan查询函数。
Group函数必须搭配Select函数一起使用
直接执行sql语句
sql := "SELECT type, count(*) as total FROM `goods` where create_time > ? GROUP BY type HAVING (total > 0)"
//因为sql语句使用了一个问号(?)作为绑定参数, 所以需要传递一个绑定参数(Raw第二个参数).
//Raw函数支持绑定多个参数
db.Raw(sql, "2022-11-06 00:00:00").Scan(&results)
fmt.Println(results)
事务和Hook
会话Session
为了避免共用 db 导致的一些问题,gorm 提供了会话模式,通过新建 session 的形式,将 db 的操作分离,互不影响。
创建 session 的时候,有一些配置:
// Session 配置
type Session struct {
DryRun bool //生成 SQL 但不执行
PrepareStmt bool //预编译模式
NewDB bool //新db 不带之前的条件
Initialized bool //初始化新的db
SkipHooks bool //跳过钩子
SkipDefaultTransaction bool //禁用默认事务
DisableNestedTransaction bool //禁用嵌套事务
AllowGlobalUpdate bool //允许不带条件的更新
FullSaveAssociations bool //允许更新关联数据
QueryFields bool //select(字段)
Context context.Context
Logger logger.Interface
NowFunc func() time.Time //允许改变 GORM 获取当前时间的实现
CreateBatchSize int
}
比如说可以禁用默认的事务,从而提供性能,官方说大致能提升 30% 左右:
// 持续会话模式
tx := db.Session(&Session{SkipDefaultTransaction: true})
tx.First(&user, 1)
tx.Find(&users)
tx.Model(&user).Update("Age", 18)
比如使用PreparedStmt
在执行任何 SQL 时都会创建一个 prepared statement 并将其缓存,以提高后续的效率
// 会话模式
tx := db.Session(&Session{PrepareStmt: true})
tx.First(&user, 1)
tx.Find(&users)
tx.Model(&user).Update("Age", 18)
// returns prepared statements manager
stmtManger, ok := tx.ConnPool.(*PreparedStmtDB)
// 关闭 *当前会话* 的预编译模式
stmtManger.Close()
// 为 *当前会话* 预编译 SQL
stmtManger.PreparedSQL // => []string{}
// 为当前数据库连接池的(所有会话)开启预编译模式
stmtManger.Stmts // map[string]*sql.Stmt
for sql, stmt := range stmtManger.Stmts {
sql // 预编译 SQL
stmt // 预编译模式
stmt.Close() // 关闭预编译模式
}
还有,gorm 的 db 默认是协程安全的,如果使用初始化参数,则 db 不在协程安全:
tx := db.Session(&gorm.Session{Initialized: true})
比如 context :
timeoutCtx, _ := context.WithTimeout(context.Background(), time.Second)
tx := db.Session(&Session{Context: timeoutCtx})
tx.First(&user) // 带有 context timeoutCtx 的查询操作
tx.Model(&user).Update("role", "admin") // 带有 context timeoutCtx 的更新操作
事务
自动事务
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
})
嵌套事务
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
})
// Commit user1, user3
手动事务
// 开始事务
tx := db.Begin()
// 在事务中执行一些 db 操作(从这里开始,您应该使用 'tx' 而不是 'db')
tx.Create(...)
// ...
// 遇到错误时回滚事务
tx.Rollback()
// 否则,提交事务
tx.Commit()
比如
// 开启事务
tx := db.Begin()
//在事务中执行数据库操作,使用的是tx变量,不是db。
//库存减一
//等价于: UPDATE `goods` SET `stock` = stock - 1 WHERE `goods`.`id` = '2' and stock > 0
//RowsAffected用于返回sql执行后影响的行数
rowsAffected := tx.Model(&goods).Where("stock > 0").Update("stock", gorm.Expr("stock - 1")).RowsAffected
if rowsAffected == 0 {
//如果更新库存操作,返回影响行数为0,说明没有库存了,结束下单流程
//这里回滚作用不大,因为前面没成功执行什么数据库更新操作,也没什么数据需要回滚。
//这里就是举个例子,事务中可以执行多个sql语句,错误了可以回滚事务
tx.Rollback()
return
}
err := tx.Create(保存订单).Error
//保存订单失败,则回滚事务
if err != nil {
tx.Rollback()
} else {
tx.Commit()
}
保存点
GORM 提供了 SavePoint
、Rollbackto
方法,来提供保存点以及回滚至保存点功能,例如:
tx := db.Begin()
tx.Create(&user1)
tx.SavePoint("sp1")
tx.Create(&user2)
tx.RollbackTo("sp1") // Rollback user2
tx.Commit() // Commit user1
Hook
Hook 是在创建、查询、更新、删除等操作之前、之后调用的函数。
如果您已经为模型定义了指定的方法,它会在创建、更新、查询、删除时自动被调用。如果任何回调返回错误,GORM 将停止后续的操作并回滚事务。
钩子方法的函数签名应该是 func(*gorm.DB) error
创建
创建时可用的 hook
// 开始事务
BeforeSave
BeforeCreate
// 关联前的 save
// 插入记录至 db
// 关联后的 save
AfterCreate
AfterSave
// 提交或回滚事务
func (u *User) BeforeCreate(tx *gorm.DB) (err error) {
u.UUID = uuid.New()
if !u.IsValid() {
err = errors.New("can't save invalid data")
}
return
}
func (u *User) AfterCreate(tx *gorm.DB) (err error) {
if u.ID == 1 {
tx.Model(u).Update("role", "admin")
}
return
}
在 GORM 中保存、删除操作会默认运行在事务上, 因此在事务完成之前该事务中所作的更改是不可见的,如果您的钩子返回了任何错误,则修改将被回滚。
func (u *User) AfterCreate(tx *gorm.DB) (err error) {
if !u.IsValid() {
return errors.New("rollback invalid user")
}
return nil
}
更新
更新时可用的 hook
// 开始事务
BeforeSave
BeforeUpdate
// 关联前的 save
// 更新 db
// 关联后的 save
AfterUpdate
AfterSave
// 提交或回滚事务
代码示例:
func (u *User) BeforeUpdate(tx *gorm.DB) (err error) {
if u.readonly() {
err = errors.New("read only user")
}
return
}
// 在同一个事务中更新数据
func (u *User) AfterUpdate(tx *gorm.DB) (err error) {
if u.Confirmed {
tx.Model(&Address{}).Where("user_id = ?", u.ID).Update("verfied", true)
}
return
}
删除
删除时可用的 hook
// 开始事务
BeforeDelete
// 删除 db 中的数据
AfterDelete
// 提交或回滚事务
代码示例:
// 在同一个事务中更新数据
func (u *User) AfterDelete(tx *gorm.DB) (err error) {
if u.Confirmed {
tx.Model(&Address{}).Where("user_id = ?", u.ID).Update("invalid", false)
}
return
}
查询
查询时可用的 hook
// 从 db 中加载数据
// Preloading (eager loading)
AfterFind
代码示例:
func (u *User) AfterFind(tx *gorm.DB) (err error) {
if u.MemberShip == "" {
u.MemberShip = "user"
}
return
}
高级查询
scope
作用域允许你复用通用的逻辑,这种共享逻辑需要定义为类型func(*gorm.DB) *gorm.DB
。
例子:
func Paginate(r *http.Request) func(db *gorm.DB) *gorm.DB {
return func (db *gorm.DB) *gorm.DB {
q := r.URL.Query()
page, _ := strconv.Atoi(q.Get("page"))
if page == 0 {
page = 1
}
pageSize, _ := strconv.Atoi(q.Get("page_size"))
switch {
case pageSize > 100:
pageSize = 100
case pageSize <= 0:
pageSize = 10
}
offset := (page - 1) * pageSize
return db.Offset(offset).Limit(pageSize)
}
}
db.Scopes(Paginate(r)).Find(&users)
db.Scopes(Paginate(r)).Find(&articles)
智能选择字段
type User struct {
ID uint
Name string
Age int
Gender string
// 假设后面还有几百个字段...
}
type APIUser struct {
ID uint
Name string
}
// 查询时会自动选择 `id`, `name` 字段
db.Model(&User{}).Limit(10).Find(&APIUser{})
// SELECT `id`, `name` FROM `users` LIMIT 10
子查询
db.Where("amount > (?)", db.Table("orders").Select("AVG(amount)")).Find(&orders)
// SELECT * FROM "orders" WHERE amount > (SELECT AVG(amount) FROM "orders");
from子查询
db.Table("(?) as u", db.Model(&User{}).Select("name", "age")).Where("age = ?", 18).Find(&User{})
// SELECT * FROM (SELECT `name`,`age` FROM `users`) as u WHERE `age` = 18
subQuery1 := db.Model(&User{}).Select("name")
subQuery2 := db.Model(&Pet{}).Select("name")
db.Table("(?) as u, (?) as p", subQuery1, subQuery2).Find(&User{})
关联操作
CREATE TABLE `gorm`.`user_profiles` (
`id` int(20) NOT NULL AUTO_INCREMENT,
`sex` tinyint(4) NULL DEFAULT NULL,
`age` int(10) NULL DEFAULT NULL,
`user_id` int(20) NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4;
比如有一个用户属性表,查询用户的时候需要将其的性别和年龄查询出来:
type UserProfile struct {
ID int64
UserId int64
Sex int
Age int
}
func (u UserProfile) TableName() string {
return "user_profiles"
}
type User struct {
ID int64
Username string `gorm:"column:username"`
Password string `gorm:"column:password"`
CreateTime int64 `gorm:"column:createtime"`
UserProfile UserProfile
}
保存User
var user = User{
Username: "ms",
Password: "ms",
CreateTime: time.Now().UnixMilli(),
UserProfile: UserProfile{
Sex: 0,
Age: 20,
},
}
DB.Save(&user)
会产生两条sql,users表和user_profiles表都有数据
这是因为默认的外键是结构体名字+下划线+id,即UserId或者表字段是user_id
如果将user_profiles表中的user_id改为other_id就会失败。
type User struct {
ID int64
Username string `gorm:"column:username"`
Password string `gorm:"column:password"`
CreateTime int64 `gorm:"column:createtime"`
UserProfile UserProfile `gorm:"foreignKey:OtherId"`
}
只要给UserProfile添加上相应的tag即可。
关联标签
标签 | 描述 |
---|---|
foreignKey | 指定当前模型的列作为连接表的外键 |
references | 指定引用表的列名,其将被映射为连接表外键 |
polymorphic | 指定多态类型,比如模型名 |
polymorphicValue | 指定多态值、默认表名 |
many2many | 指定连接表表名 |
joinForeignKey | 指定连接表的外键列名,其将被映射到当前表 |
joinReferences | 指定连接表的外键列名,其将被映射到引用表 |
constraint | 关系约束,例如:OnUpdate 、OnDelete |
查询
var users []User
err := DB.Preload("UserProfile").Find(&users).Error
fmt.Println(err)
fmt.Println(users)
Preload预加载,直接加载关联关系
也可以使用joins进行加载关联数据:
var users []User
err := DB.Joins("UserProfile").Find(&users).Error
fmt.Println(err)
fmt.Println(users)
从sql中能看的出来,使用了left join。
如果不想要User的数据,只想要关联表的数据,可以这么做:
var user User
DB.Where("id=?", 25).Take(&user)
var userProfile UserProfile
err := DB.Model(&user).Association("UserProfile").Find(&userProfile)
fmt.Println(err)
fmt.Println(userProfile)
总结
本次细致的讲解了如何使用 Gorm,我们之后会对本文章进行持续更新。