GORM学习
大部分实例来自文档
模型
模型定义
实例1
2
3
4
5
6
7
8
9
10
11
12type User struct {
gorm.Model
Name string
Age sql.NullInt64
Birthday *time.Time
Email string `gorm:"type:varchar(100);unique_index"`
Role string `gorm:"size:255"` //设置字段的大小为255个字节
MemberNumber *string `gorm:"unique;not null"` // 设置 memberNumber 字段唯一且不为空
Num int `gorm:"AUTO_INCREMENT"` // 设置 Num字段自增
Address string `gorm:"index:addr"` // 给Address 创建一个名字是 `addr`的索引
IgnoreMe int `gorm:"-"` //忽略这个字段
}
支持的结构标签1
2
3
4
5
6
7
8
9
10
11
12
13
14
15标签 说明
Column 指定列的名称
Type 指定列的类型
Size 指定列的大小，默认是 255
PRIMARY_KEY 指定一个列作为主键
UNIQUE 指定一个唯一的列
DEFAULT 指定一个列的默认值
PRECISION 指定列的数据的精度
NOT NULL 指定列的数据不为空
AUTO_INCREMENT 指定一个列的数据是否自增
INDEX 创建带或不带名称的索引，同名创建复合索引
UNIQUE_INDEX 类似 索引，创建一个唯一的索引
EMBEDDED 将 struct 设置为 embedded
EMBEDDED_PREFIX 设置嵌入式结构的前缀名称
- 忽略这些字段
关联的结构标签
有关详细信息，请查看「关联」部分1
2
3
4
5
6
7
8
9
10
11
12
13标签 说明
MANY2MANY 指定连接表名称
FOREIGNKEY 指定外键
ASSOCIATION_FOREIGNKEY 指定关联外键
POLYMORPHIC 指定多态类型
POLYMORPHIC_VALUE 指定多态的值
JOINTABLE_FOREIGNKEY 指定连接表的外键
ASSOCIATION_JOINTABLE_FOREIGNKEY 指定连接表的关联外键
SAVE_ASSOCIATIONS 是否自动保存关联
ASSOCIATION_AUTOUPDATE 是否自动更新关联
ASSOCIATION_AUTOCREATE 是否自动创建关联
ASSOCIATION_SAVE_REFERENCE 是否引用自动保存的关联
PRELOAD 是否自动预加载关联
实例
PS：gorm支持自动迁移，但是要注意的几点是：它只会创建表，补充缺少的列和缺少的索引。但并不会更改已经存在的列类型、不会更改列名、也不会删除不再用的列，这样设计的目的是为了保护已存在的数据。
gorm.Model是这么定义的，这个方便嵌入我们的模型1
2
3
4
5
6
7
8
9
10
11type Model struct {
ID uint `gorm:"primary_key"`
CreatedAt time.Time
UpdatedAt time.Time
DeletedAt *time.Time `sql:"index"`
}
type Use struct{
gorm.Model
Username string
}
表名默认是结构体的复数形式1
2
3
4
5
6
7
8
9type User struct {} // 默认表名是`users`
//设置表名
func (User)TableName()string{
return "user"
}
//禁用表名复数形式
db.SingularTable(true) //当为true时，默认为user，而不是users
我们还可以更改默认表名，我们可以通过DefaultTableNameHandler来更改默认命名规则1
2
3gorm.DefaultTableNameHandler=func(db *gorm.DB, defaultTableName string) string {
return "gorm_"+defaultTableName
}
列名默认是字段名的蛇形小写1
2
3
4
5
6
7
8
9
10
11
12type User struct {
gorm.Model
UserName string //迁移到mysql的时候会变成user_name
PassWord string //迁移到mysql的时候会变成pass_word
}
//但是我们可以通过tag来改变字段名
type User struct {
gorm.Model
UserName string `gorm:"column:username"`
PassWord string `gorm:"column:password"`
}
指定名称创建一个表1
db.Table("test_grom").CreateTable(&User{})
连接数据库
你可以使用原生的数据库驱动程序连接，但是没有这个必要，因为gorm里面封装了部分常见的驱动，连接的参数和原生都差不多。
仅仅包含下面4种主流的关系型数据库，但是对我们来说已经基本够用了1
2
3
4import _ "github.com/jinzhu/gorm/dialects/mysql"
import _ "github.com/jinzhu/gorm/dialects/postgres"
import _ "github.com/jinzhu/gorm/dialects/sqlite"
import _ "github.com/jinzhu/gorm/dialects/mssql"
MySQL1
2
3
4
5
6
7
8
9
10
11
12
13
14
15package main
import (
_ "github.com/jinzhu/gorm/dialects/mysql"
"github.com/jinzhu/gorm"
)
func main(){
db, err := gorm.Open("mysql", "root:123456@/user?charset=utf8&parseTime=True&loc=Local")
if err!=nil{
return
}
defer db.Close()
}
PostgreSQL1
2
3
4
5
6
7
8
9
10
11
12
13
14
15package main
import (
_ "github.com/jinzhu/gorm/dialects/postgres"
"github.com/jinzhu/gorm"
)
func main(){
db, err := gorm.Open("postgres", "host=myhost user=gorm dbname=gorm sslmode=disable password=mypassword")
if err!=nil{
return
}
defer db.Close()
}
SQLite31
2
3
4
5
6
7
8
9
10
11
12
13import (
"github.com/jinzhu/gorm"
_ "github.com/jinzhu/gorm/dialects/sqlite"
)
func main() {
db, err := gorm.Open("sqlite3", "./test.db")
if err!=nil{
return
}
defer db.Close()
}
判断表是否存在
1 | // 检查模型`User`表是否存在 |
CRUD
创建记录
1 | var zhangsan =User{ |
我们通过db.NewRecord来判断是否插入成功，成功则放回false，失败则返回true。
默认值
我们可以通过tag设置默认值，PS: 只有在建表有效，不能在建表之后在使用1
2
3
4
5
6
7
8type User struct {
gorm.Model
Username string `gorm:"column:username"`
Password string `gorm:"column:password"`
Email string
Blog string `gorm:"default:'test@test.com'"`
Phone uint
}
查询
1 | // 获取第一条记录，按主键排序 |
Where1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25// 获取第一条匹配的记录
db.Where("name = ?", "jinzhu").First(&user)
//// SELECT * FROM users WHERE name = 'jinzhu' limit 1;
// 获取所有匹配的记录
db.Where("name = ?", "jinzhu").Find(&users)
//// SELECT * FROM users WHERE name = 'jinzhu';
// <>
db.Where("name <> ?", "jinzhu").Find(&users)
// IN
db.Where("name in (?)", []string{"jinzhu", "jinzhu 2"}).Find(&users)
// LIKE
db.Where("name LIKE ?", "%jin%").Find(&users)
// AND
db.Where("name = ? AND age >= ?", "jinzhu", "22").Find(&users)
// Time
db.Where("updated_at > ?", lastWeek).Find(&users)
// BETWEEN
db.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&users)
使用struct和map1
2
3
4
5
6
7
8
9
10
11
12Struct & Map
// Struct
db.Where(&User{Name: "jinzhu", Age: 20}).First(&user)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 20 LIMIT 1;
// Map
db.Where(map[string]interface{}{"name": "jinzhu", "age": 20}).Find(&users)
// SELECT * FROM users WHERE name = "jinzhu" AND age = 20;
// 多主键 slice 查询
db.Where([]int64{20, 21, 22}).Find(&users)
// SELECT * FROM users WHERE id IN (20, 21, 22);
PS：这里要注意的一点是，查询条件不会包含"",0,false和其它空值，例如：db.Where(&User{Username:"lisi",Password:""}).Find(&u)里面的password=""，是不会带入查询条件中的
Not1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21db.Not("name", "jinzhu").First(&user)
//// SELECT * FROM users WHERE name <> "jinzhu" LIMIT 1;
// 不包含
db.Not("name", []string{"jinzhu", "jinzhu 2"}).Find(&users)
//// SELECT * FROM users WHERE name NOT IN ("jinzhu", "jinzhu 2");
//不在主键 slice 中
db.Not([]int64{1,2,3}).First(&user)
//// SELECT * FROM users WHERE id NOT IN (1,2,3);
db.Not([]int64{}).First(&user)
//// SELECT * FROM users;
// 原生 SQL
db.Not("name = ?", "jinzhu").First(&user)
//// SELECT * FROM users WHERE NOT(name = "jinzhu");
// Struct
db.Not(User{Name: "jinzhu"}).First(&user)
//// SELECT * FROM users WHERE name <> "jinzhu";
OR1
2
3
4
5
6
7
8
9
10db.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"}).Find(&users)
// SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';
// Map
db.Where("name = 'jinzhu'").Or(map[string]interface{}{"name": "jinzhu 2"}).Find(&users)
// SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';
行内条件查询1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21// 通过主键进行查询 (仅适用于主键是数字类型)
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;
// 原生 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;
FirstOrInit
获取第一条匹配的记录，或者通过给定的条件下初始一条新的记录（仅适用与于 struct 和 map 条件）。还要注意的几点是：这个不会在数据库里面增加记录，只是会改变传入的结构体的值，而且不支持结构体数组
1 | // 未查询到 |
Attrs
如果未找到记录，则使用参数初始化 struct1
2
3
4
5
6
7
8
9
10
11
12
13// 未查询到
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}
Assign
无论是否查询到数据，都将参数赋值给 struct
1 | // 未查询到 |
FirstOrCreate
获取第一条匹配的记录，或者通过给定的条件创建一条记录 （仅适用与于 struct 和 map 条件）。
1 | // 未查询到 |
指定字段查询
指定要从数据库检索的字段，默认情况下，将选择所有字段。
1 | db.Select("name, age").Find(&users) |
Order
使用 Order 从数据库查询记录时，当第二个参数设置为 true 时，将会覆盖之前的定义条件。
1 | db.Order("age desc, name").Find(&users) |
Limit
指定要查询的最大记录数
1 | db.Limit(3).Find(&users) |
Count
获取模型记录数，这个传入的是整形
1 | db.Where("name = ?", "jinzhu").Or("name = ?", "jinzhu 2").Find(&users).Count(&count) |
Scan
将 Scan 查询结果放入另一个结构体中。
1 | type Result struct { |
1 | var result Result |
更新
更新所有字段
Save 方法在执行 SQL 更新操作时将包含所有字段，即使这些字段没有被修改。1
2
3
4
5db.First(&user)
user.Name = "jinzhu 2"
user.Age = 100
db.Save(&user)
// UPDATE users SET name='jinzhu 2', age=100, birthday='2016-01-01', updated_at = '2013-11-17 21:34:10' WHERE id=111;
更新已更改的字段
如果你只想更新已经修改了的字段，可以使用 Update，Updates 方法。
1 | // 如果单个属性被更改了，更新它 |
更新选中的字段
如果你在执行更新操作时只想更新或者忽略某些字段，可以使用 Select，Omit 方法。
1 | db.Model(&user).Select("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "actived": false}) |
更新列钩子方法
上面的更新操作更新时会执行模型的 BeforeUpdate 和 AfterUpdate 方法，来更新 UpdatedAt 时间戳，并且保存他的 关联。如果你不想执行这些操作，可以使用 UpdateColumn，UpdateColumns 方法。1
2
3
4
5
6
7// Update single attribute, similar with `Update`
db.Model(&user).UpdateColumn("name", "hello")
//// UPDATE users SET name='hello' WHERE id = 111;
// Update multiple attributes, similar with `Updates`
db.Model(&user).UpdateColumns(User{Name: "hello", Age: 18})
//// UPDATE users SET name='hello', age=18 WHERE id = 111;
批量更新
批量更新时，钩子函数不会执行
1 | db.Table("users").Where("id IN (?)", []int{10, 11}).Updates(map[string]interface{}{"name": "hello", "age": 18}) |
带有表达式的 SQL 更新1
2
3
4
5
6
7
8
9
10
11DB.Model(&product).Update("price", gorm.Expr("price * ? + ?", 2, 100))
//// UPDATE "products" SET "price" = price * '2' + '100', "updated_at" = '2013-11-17 21:34:10' WHERE "id" = '2';
DB.Model(&product).Updates(map[string]interface{}{"price": gorm.Expr("price * ? + ?", 2, 100)})
//// UPDATE "products" SET "price" = price * '2' + '100', "updated_at" = '2013-11-17 21:34:10' WHERE "id" = '2';
DB.Model(&product).UpdateColumn("quantity", gorm.Expr("quantity - ?", 1))
//// UPDATE "products" SET "quantity" = quantity - 1 WHERE "id" = '2';
DB.Model(&product).Where("quantity > 1").UpdateColumn("quantity", gorm.Expr("quantity - ?", 1))
//// UPDATE "products" SET "quantity" = quantity - 1 WHERE "id" = '2' AND quantity > 1;
在钩子函数中更新值
如果你想使用 BeforeUpdate、BeforeSave 钩子函数修改更新的值，可以使用 scope.SetColumn 方法，例如：1
2
3
4
5func (user *User) BeforeSave(scope *gorm.Scope) (err error) {
if pw, err := bcrypt.GenerateFromPassword(user.Password, 0); err == nil {
scope.SetColumn("EncryptedPassword", pw)
}
}
额外的更新选项
1 | // 在更新 SQL 语句中添加额外的 SQL 选项 |
删除
条件删除
删除匹配的记录
1 | db.Where("email LIKE ?", "%jinzhu%").Delete(Email{}) |
软删除
如果模型中有 DeletedAt 字段，它将自动拥有软删除的能力！当执行删除操作时，数据并不会永久的从数据库中删除，而是将 DeletedAt 的值更新为当前时间。
1 | db.Delete(&user) |
链式操作
所有的链式操作都将会克隆并创建一个新的数据库对象（共享一个连接池），
GORM对于多个goroutines的并发使用是安全的。
简单的链式操作
Gorm 继承了链式操作接口1
2
3
4
5
6var u []User
st:=db.Where("id>?",17)
if true{
st=st.Where("phone=?",123)
}
st.Find(&u)
也可以这么写1
db.Where().Where().Find()
封装成方法
Scope方法基于链式操作理论创建的。
1 |
|
错误处理
处理单个错误
如果发生任何错误，GORM 会将其设置为 * gorm.DB 的 Error 字段1
2
3
4
5
6
7var u []User
//这里故意写错一个表达式
if err:=db.Where("id : ?",22).Find(&u).Error;err!=nil{
fmt.Println(err.Error())
}else{
fmt.Println(u)
}
或者这么写1
2
3
4
5
6
7
8var u []User
//这里故意写错一个表达式
rs:=db.Where("id : ?",22).Find(&u)
if rs.Error!=nil{
fmt.Println(rs.Error.Error())
}else{
fmt.Println(u)
}
处理多个错误
在处理数据期间，发生几个错误很普遍，GORM 提供了一个 API 来将所有发生的错误作为切片返回
如果有多个错误产生，GetErrors 返回一个 []error的切片
1 | var u []User |
事务
GORM默认在事务中执行单个 create， update， delete 操作，以确保数据库数据完整性。
如果你想将多个 create， update， delete 当成一个原子性操作，Transaction就是为了这个而创造的。
要在事务中执行一组操作，正常的流程如下所示。1
2
3
4
5
6
7
8
9
10
11
12
13// 开启事务
tx := db.Begin()
// 在事务中执行一些数据库操作 （从这里开始使用 'tx'，而不是 'db'）
tx.Create(...)
// ...
// 发生错误回滚事务
tx.Rollback()
// 或者提交这个事务
tx.Commit()
1 | var err error |
原生SQL语句
通用数据库接口
GORM 提供了从当前的*gorm.DB连接中返回通用的数据库接口的方法DB *sql.DB。1
2
3
4// 获取通用数据库对象 sql.DB 来使用他的 db.DB() 方法
// Ping
db.DB().Ping()
连接池
1 | // SetMaxIdleConns 设置空闲连接池中的最大连接数。 |
自定义logger
Gorm 建立了对 Logger 的支持，默认模式只会在错误发生的时候打印日志。1
2
3
4
5
6
7
8// 开启 Logger, 以展示详细的日志
db.LogMode(true)
// 关闭 Logger, 不再展示任何日志，即使是错误日志
db.LogMode(false)
// 对某个操作展示详细的日志，用来排查该操作的问题
db.Debug().Where("name = ?", "jinzhu").First(&User{})
数据库迁移
使用 migrate 来维持你的表结构一直处于最新状态。
警告：migrate 仅支持创建表，没有的字段和没有索引。为了保护你的数据，它并不支持改变已有的字段类型或删除未被使用的字段1
2
3
4
5
6db.AutoMigrate(&User{})
db.AutoMigrate(&User{}, &Product{}, &Order{})
// 创建表的时候，添加表后缀
db.Set("gorm:table_options", "ENGINE=InnoDB").AutoMigrate(&User{})
其他数据库迁移工具
GORM 的数据库迁移工具能够支持主要的数据库，但是如果你要寻找更多的迁移工具， GORM 会提供的数据库接口，这可能可以给到你帮助。1
2// 返回 `*sql.DB`
db.DB()
表结构的方法
Has Table1
2
3
4
5// 检查模型中 User 表是否存在
db.HasTable(&User{})
// 检查 users 表是否存在
db.HasTable("users")
Create Table1
2
3
4
5// 通过模型 User 创建表
db.CreateTable(&User{})
// 在创建 users 表的时候，会在 SQL 语句中拼接上 `"ENGINE=InnoDB"`
db.Set("gorm:table_options", "ENGINE=InnoDB").CreateTable(&User{})
Drop table1
2
3
4
5
6
7
8// 删除模型 User 表
db.DropTable(&User{})
// 删除 users 表
db.DropTable("users")
// 删除模型 User 表和 products 表
db.DropTableIfExists(&User{}, "products")
ModifyColumn
以给定的值来定义字段类型1
2// User 模型，改变 description 字段的数据类型为 `text`
db.Model(&User{}).ModifyColumn("description", "text")
DropColumn1
2// User 模型，删除 description 字段
db.Model(&User{}).DropColumn("description")
Add Indexes1
2
3
4
5
6
7
8
9
10
11// 为 `name` 字段建立一个名叫 `idx_user_name` 的索引
db.Model(&User{}).AddIndex("idx_user_name", "name")
// 为 `name`, `age` 字段建立一个名叫 `idx_user_name_age` 的索引
db.Model(&User{}).AddIndex("idx_user_name_age", "name", "age")
// 添加一条唯一索引
db.Model(&User{}).AddUniqueIndex("idx_user_name", "name")
// 为多个字段添加唯一索引
db.Model(&User{}).AddUniqueIndex("idx_user_name_age", "name", "age")
Remove Index1
2// 移除索引
db.Model(&User{}).RemoveIndex("idx_user_name")
Add Foreign Key1
2
3
4
5
6
7
8// 添加主键
// 第一个参数 : 主键的字段
// 第二个参数 : 目标表的 ID
// 第三个参数 : ONDELETE
// 第四个参数 : ONUPDATE
db.Model(&User{}).AddForeignKey("city_id", "cities(id)", "RESTRICT", "RESTRICT")
Remove ForeignKey
db.Model(&User{}).RemoveForeignKey("city_id", "cities(id)")
