Go 语言编程 — gorm ORM 框架

目录

实现一个关系型数据库应用程序需要做什么?

  • DB API:数据库操作的封装接口。
  • DAO(Data Access Object)Models:数据库 Table(表)、Column(列属性)、Relationship(关联关系)的定义。
  • DB Migrate:数据库的自动化灰度升级、降级实现。

GORM

GORM 是一个 Golang 的第三方库,由国人开源的轻量级关系型 ORM 库。

  • Github:https://github.com/jinzhu/gorm
  • 中文文档:http://gorm.io/zh_CN/
  • Jinzhu 本人的 Topic:https://www.bilibili.com/video/BV1pE411N7Sv
  • V2.0:https://gorm.io/zh_CN/docs/v2_release_note.html

GORM 基于 Golang build-in 的 database/sql 库进行扩展,增加了对面向对象编程更加友好的 ORM 机制。开发者只需要定义好 Struct 数据结构,由 GORM 来完成 Struct 到 ModelStruct 的转换(结构体映射为 Table,结构体成员映射为 Column),并提供了标准的方法进行数据操作,例如:Create、Update、Delete、Where 等

GORM 的特点:

  • 支持 MySQL、PostgreSQL、SQLite、SQLServer 等数据库。
  • 支持 One to One、One to Many、Many To Many、Polymorphism(多态)等多种关联处理类型。
  • 支持钩子(Hook)机制,可以在执行 Create、Save、Update、Delete、Find 操作之前或之后进行回调,具有良好的可扩展性。
  • 支持复合主键:多个属性构成一个主键,常用作索引。
  • 支持自动迁移(Auto-Migrtion)。
  • 支持原生 SQL 操作。
  • 支持链式 API。
  • 支持热加载。
  • 支持事务性。
  • 支持日志。

安装:

go get -u github.com/jinzhu/gorm

连接数据库

要连接到数据库首先要导入相应的驱动程序。GORM 目前支持 4 种关系型数据库:

import _ "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"

其实这些库本质是 Golang database/sql 实现的驱动,在 GORM 中取了个别名。需要注意的是,即便不导入这些驱动,也并不影响程序的编译,但却无法正常运行。针对这个 “不确定性” 的实现,在 GORM 2.0 被优化为需要显式传入的实参。

以 PostgreSQL 为例,直接调用 gorm.Open 函数传入 DB URI 即可。

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

func main() {
  db, err := gorm.Open("postgres", "host=myhost port=myport user=gorm dbname=gorm password=mypassword")
  defer db.Close()
}

表定义

GORM 的表定义很简单,应用了 Golang 的 Struct Tag 和 Reflect(反射)机制。我们用 “Model Struct” 来描述此类特殊的 ORM Struct。在定义好 Model Struct 之后,直接调用 db.CreateTable 函数就可以创建表了。

基本上:

  • Struct Name 就是 Table Name,表名默认为小写字母复数形式。
  • Struct Members 就是 Table Columns。
  • Struct Tag 使用 gorm:“XXX” 进行 Column 的属性定义,包括:主键、外键、非空等约束。GORM 也会设置缺省的默认属性。

示例:

type Model struct {
	ID        uint `gorm:"primary_key"`              // id 为主键
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt *time.Time `sql:"index"`
}

type 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"`       // 设置会员号唯一并且不为空
  Num          int     `gorm:"AUTO_INCREMENT"`        // 设置 num 为自增类型
  Address      string  `gorm:"index:addr"`            // 给 address 字段创建名为 addr的 索引
  IgnoreMe     int     `gorm:"-"`                     // 忽略本字段
}

还可以通过 db.Set 函数设置额外的表属性。例如,设置日志:

db.LogMode(true)
db.SetLogger(gorm.Logger{revel.TRACE})
db.SetLogger(log.New(os.Stdout, "\r\n", 0))

Module Struct tags

Tag描述
Column指定列名
Type指定列数据类型
Size指定列大小,默认值 255
PRIMARY_KEY指定列的主键约束,默认会使用名为 ID 的字段作为表的主键
UNIQUE指定列的唯一约束
DEFAULT指定列的默认值
PRECISION指定列的精度
NOT NULL指定列的非空约束
AUTO_INCREMENT指定列为自增类型
INDEX创建具有或不带名称的索引,如果多个索引同名则创建为复合索引
UNIQUE_INDEX和 INDEX 类似,只不过创建的是唯一索引
EMBEDDED将结构设置为嵌入
EMBEDDED_PREFIX设置嵌入结构的前缀
-忽略此字段
MANY2MANY指定多对多连接的表
FOREIGNKEY指定列的外键约束
ASSOCIATION_FOREIGNKEY设置关联外键
POLYMORPHIC指定多态类型
POLYMORPHIC_VALUE指定多态值
JOINTABLE_FOREIGNKEY指定连接表的外键
ASSOCIATION_JOINTABLE_FOREIGNKEY指定连接表的关联外键
SAVE_ASSOCIATIONS是否自动完成 save 的相关操作
ASSOCIATION_AUTOUPDATE是否自动完成 update 的相关操作
ASSOCIATION_AUTOCREATE是否自动完成 create 的相关操作
ASSOCIATION_SAVE_REFERENCE是否自动完成引用的 save 的相关操作
PRELOAD是否自动完成预加载的相关操作

表操作

db.HasTable 表是否存在

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

// 检查表 users 是否存在
db.HasTable("users")

db.CreateTable 创建表

// 为模型 `User` 创建表
db.CreateTable(&User{})

// 创建表时会追加 “ENGINE=InnoDB” 到 SQL 语句中。
db.Set("gorm:table_options", "ENGINE=InnoDB").CreateTable(&User{})

db.DropTable 删除表

// 删除模型 `User` 的表
db.DropTable(&User{})

// 删除表 `users`
db.DropTable("users")

// 删除模型 `User` 的表和表 `products`
db.DropTableIfExists(&User{}, "products")

db.ModifyColumn 修改列

// 修改模型 `User` 的 description 列的类型为 `text` 
db.Model(&User{}).ModifyColumn("description", "text")

db.DropColumn 删除列

// 删除模型 `User` 的 description 列
db.Model(&User{}).DropColumn("description")

db.AddIndex 添加索引

// 为 `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")

db.RemoveIndex 删除索引

// 删除索引
db.Model(&User{}).RemoveIndex("idx_user_name")

db.AddForeignKey 添加外键

// 添加外键
// 第一个参数: 外键字段
// 第二个参数:目标表名(字段)
// 第三个参数:删除时
// 第四个参数: 更新时
db.Model(&User{}).AddForeignKey("city_id", "cities(id)", "RESTRICT", "RESTRICT")

db.RemoveForeignKey 删除外键

db.Model(&User{}).RemoveForeignKey("city_id", "cities(id)")

CRUD 操作

GORM 支持使用链式 API 来完成对 Table 的 CURD 操作,所有链式方法都会创建并克隆一个新的 db 对象 (共享一个连接池),GORM 在多 Goroutine 中是并发安全的。任何时候都可以不断的基于 db 对象调用函数来完成预期的操作,包括调用 db.Error 就能获取到错误信息。

db.Create 插入

调用 db.Create 方法即可完成数据库表记录的插入。需要注意的是,GORM 生成的 SQL 语句会排除零值字段:所有字段的零值,比如 0、’’、false,都不会保存到数据库内。将记录插入到数据库后,Gorm会从数据库加载那些字段的值到变量对象。

var animal = Animal{Age: 99, Name: ""}
db.Create(&animal)
// INSERT INTO animals("age") values('99');
// SELECT name from animals WHERE ID=111; // 返回主键为 111
// animal.Name => 'galeone'

db.First、db.Find 查询

// 根据主键查询第一条记录
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;

// 查询所有的记录
db.Find(&users)
 SELECT * FROM users;

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

db.Where 选择

// 获取第一个匹配的记录
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)
 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)
 SELECT * FROM users WHERE created_at BETWEEN '2000-01-01 00:00:00' AND '2000-01-08 00:00:00';

当通过结构体进行 WHERE 过滤查询时,GORM 只会通过其中的非零值字段进行查询,例如:0、’’、false 或者其他零值将不会被用于构建查询条件。

// 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;

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

db.Where(&User{Name: "jinzhu", Age: 0}).Find(&users)
 SELECT * FROM users WHERE name = "jinzhu";
  • db.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"}).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';

db.Select 投影

db.Select 指定你想从数据库中检索出的字段,默认会选择全部字段。

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;

db.Joins 连接

db.Joins 指定连接条件:

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)

// 多连接及参数
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)

db.Order 排序

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)

db.Limit 限量

db.Limit 指定从数据库检索出的最大记录数。

db.Limit(3).Find(&users)
 SELECT * FROM users LIMIT 3;

// -1 取消 Limit 条件
db.Limit(10).Find(&users1).Limit(-1).Find(&users2)
 SELECT * FROM users LIMIT 10; (users1)
 SELECT * FROM users; (users2)

db.Offset 偏移量

db.Offset 指定开始返回记录前要跳过的记录数。

db.Offset(3).Find(&users)
 SELECT * FROM users OFFSET 3;

// -1 取消 Offset 条件
db.Offset(10).Find(&users1).Offset(-1).Find(&users2)
 SELECT * FROM users OFFSET 10; (users1)
 SELECT * FROM users; (users2)

db.Count 总数

注意:Count 必须是链式查询的最后一个操作 ,因为它会覆盖前面的 SELECT。

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)

db.Update 更新

更新所有字段

db.Save 会更新所有字段,即使你没有赋值。

db.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;

更新修改字段

// 更新单个属性,如果它有变化
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, "actived": false})
 UPDATE users SET name='hello', age=18, actived=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, Actived: false})

更新选定字段

如果你想更新或忽略某些字段,你可以使用 Select、Omit:

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

db.Delete 删除

注:删除记录时,一定要确保主键字段有值,否则会删除该 Model 的所有记录。这一点在 GORM 2.0 有了改进,这种情况时会触发错误。

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

软删除

如果 model 有 DeletedAt 字段,那么该 model 具有软删除的功能。当调用 Delete 方法时,记录不会真正的从数据库中被删除,只会将DeletedAt 字段的值会被设置为当前时间,表示 “已删除”。

db.Delete(&user)
 UPDATE users SET deleted_at="2013-10-29 10:23" WHERE id = 111;

// 查询记录时会忽略被软删除的记录
db.Where("age = 20").Find(&user)
 SELECT * FROM users WHERE age = 20 AND deleted_at IS NULL;

// Unscoped 方法可以查询被软删除的记录
db.Unscoped().Where("age = 20").Find(&users)
 SELECT * FROM users WHERE age = 20;

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

关系(Relationship)类型

总的来说,现实世界的实体之间拥有 3 种类型的关系:

  • 一对多:表示一对多关系时,在子表中通过外键引用父表。
  • 一对一:表示一对一关系时,本质是在两张表之间建立双向关系。一对一可以看作是特殊的 “一对多”,在双方看来,对方都是一对多的关系。
  • 多对多:表示多对多关系时,表示两张表彼此都可以相互引用对方的多个记录。多对多关系会在两个表之间额外的增加一个关联的表。这个关联表通常只有两个属性,分别为另外两张表的外键。

而 GORM 基于这 3 种关系具现化为了更加实际的类型:Belongs To、Has One、Many To Many 等。在定义 Model Struct 的时,就可以设定这些实体之间的关系,GORM 会自定维护这些关系在数据库中的数据记录,例如:自动填充主键、外键之间的映射、自动维护多对多关联表等。

Belongs To

A belongs to B,表示 A 属于 B,两者是一对一的关系。定义 Belongs To 关系时,A 的外键必须存在,并且是 B 的主键。

type User struct {
  gorm.Model
  Name string
}

// Profile 属于 User
type Profile struct {
  gorm.Model
  Name   string
  UserID int
  User   User    // 外键
}

使用 db.Related 查找 belongs to 关系:

db.Model(&user).Related(&profile)
 SELECT * FROM profiles WHERE user_id = 111; // 111 is user's ID

Has One

A has one B,表示 A “必然” 包含一个 B,两者是一对一的关系。注意,“必然” 意味着 A 总是包含 B 的。B 必须有一个外键,并且是 A 的主键。

// User 只能拥有一张 CreditCard
type User struct {
  gorm.Model
  CreditCard   CreditCard
}

type CreditCard struct {
  gorm.Model
  Number   string
  UserID   uint    // 外键
}

通过 db.Related 使用 has one 关联:

var card CreditCard
db.Model(&user).Related(&card, "CreditCard")
 SELECT * FROM credit_cards WHERE user_id = 123; // 123 is user's primary key
// CreditCard 是 users 的字段,其含义是,获取 user 的 CreditCard 并填充至 card 变量
// 如果字段名与 model 名相同,比如上面的例子,此时字段名可以省略不写,像这样:
db.Model(&user).Related(&card)

Has Many

A has many B,A 包含了多个 B,两种是一对多的关系。

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

type CreditCard struct {
  gorm.Model
  Number   string
  UserID  uint    // 外键
}

通过 db.Related 使用 has many 关联:

db.Model(&user).Related(&emails)
 SELECT * FROM emails WHERE user_id = 111; // 111 是 user 的主键

Many To Many

Many To Many,多对多关系,需要在两个 model 中添加一张连接表。

比如说,User 和 Language,一个 User 可以说多种 Language,多个 User 也可以说一种 Language,连接表为 user_languages。

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

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

var users []User
language := Language{}

db.First(&language, "id = ?", 111)

db.Model(&language).Related(&users,  "Users")
 SELECT * FROM "users" INNER JOIN "user_languages" ON "user_languages"."user_id" = "users"."id" WHERE  ("user_languages"."language_id" IN ('111'))

GORM 将为这两个 Struct 创建多对多关系,并且他们的关系将被保存到连接表 user_languages。

db.Model(&user).Related(&languages, "Languages")
 SELECT * FROM "languages" INNER JOIN "user_languages" ON "user_languages"."language_id" = "languages"."id" WHERE "user_languages"."user_id" = 111

// 查询 user 时会预加载 Languages
db.Preload("Languages").First(&user)

关联(Associations)

关联(Associations)是 GORM 的操作对象,与关系(Relationship)有所区别:

  • 关系:实体之间的关系,社会学用语。
  • 关联:实体之间的联系,工程学用语。
// 开始使用关联模式
var user User
db.Model(&user).Association("Languages")
// `user` 是源,必须包含主键
// `Languages` 是关系中的源的字段名
// 只有在满足上面两个条件时,关联模式才能正常工作,请注意检查错误:
// db.Model(&user).Association("Languages").Error

创建/更新记录时,GORM 将自动保存关联及其引用。如果关联具有主键,GORM 将调用 Update 来保存它,否则将创建它:

user := User{
  Name:            "jinzhu",
  BillingAddress:  Address{Address1: "Billing Address - Address 1"},
  ShippingAddress: Address{Address1: "Shipping Address - Address 1"},
  Emails:          []Email{
    {Email: "jinzhu@example.com"},
    {Email: "jinzhu-2@example.com"},
  },
  Languages:       []Language{
    {Name: "ZH"},
    {Name: "EN"},
  },
}

db.Create(&user)    // GORM 自动维护数据库中的关联关系。
 BEGIN TRANSACTION;
 INSERT INTO "addresses" (address1) VALUES ("Billing Address - Address 1");
 INSERT INTO "addresses" (address1) VALUES ("Shipping Address - Address 1");
 INSERT INTO "users" (name,billing_address_id,shipping_address_id) VALUES ("jinzhu", 1, 2);
 INSERT INTO "emails" (user_id,email) VALUES (111, "jinzhu@example.com");
 INSERT INTO "emails" (user_id,email) VALUES (111, "jinzhu-2@example.com");
 INSERT INTO "languages" ("name") VALUES ('ZH');
 INSERT INTO user_languages ("user_id","language_id") VALUES (111, 1);
 INSERT INTO "languages" ("name") VALUES ('EN');
 INSERT INTO user_languages ("user_id","language_id") VALUES (111, 2);
 COMMIT;

db.Save(&user)

查找关联

db.Model(&user).Association("Languages").Find(&languages)

添加关联

为 Many To Many,Has Many 关系添加一个新的关联,用于替代当前的关联:

db.Model(&user).Association("Languages").Append([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Append(Language{Name: "DE"})

替换关联

db.Model(&user).Association("Languages").Replace([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Replace(Language{Name: "DE"}, languageEN)

删除关联

db.Model(&user).Association("Languages").Delete([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Delete(languageZH, languageEN)

清空关联

db.Model(&user).Association("Languages").Clear()

关联的数量

db.Model(&user).Association("Languages").Count()

预加载

当 Models 之间具有关系时,就可以通过 GORM 的 Preloading(预加载)机制,预先完成多表级联加载,以此来提升访问效率,但同时也会为数据库带来一定的压力。

GORM 默认开启预加载功能,也可以显式的关闭:gorm:"PRELOAD:false

// 下面的例子会用到 User 和 Order 结构体

type User struct {
  gorm.Model
  Username string
  Orders Order
}

type Order struct {
  gorm.Model
  UserID uint
  Price float64
}

db.Preload("Orders").Find(&users)
 SELECT * FROM users;
 SELECT * FROM orders WHERE user_id IN (1,2,3,4);

db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
 SELECT * FROM users;
 SELECT * FROM orders WHERE user_id IN (1,2,3,4) AND state NOT IN ('cancelled');

db.Where("state = ?", "active").Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
 SELECT * FROM users WHERE state = 'active';
 SELECT * FROM orders WHERE user_id IN (1,2) AND state NOT IN ('cancelled');

db.Preload("Orders").Preload("Profile").Preload("Role").Find(&users)
 SELECT * FROM users;
 SELECT * FROM orders WHERE user_id IN (1,2,3,4); // has many
 SELECT * FROM profiles WHERE user_id IN (1,2,3,4); // has one
 SELECT * FROM roles WHERE id IN (4,5,6); // belongs to

事务

GORM 默认会将单个的 create, update, delete 操作封装在事务内进行处理,以确保数据的完整性。如果你想把多个 create, update, delete 操作作为一个原子操作,就需要采用事务机制了。

Migrate

Migrate,使你的 Models 保持最新状态。数据库应用程序的 E-R 模型总是演进的,这里就会出现一个需求:怎样在保证原有生产数据完整性的情况下对数据库进行升级,或回滚到之前的某一个时刻以复现环境。

注意,GORM 的自动迁移(Auto-Migrate)只会创建表、缺失的列、缺失的索引,不会更改现有列的类型或删除未使用的列,以此来保护数据的完整性。

db.AutoMigrate(&User{})

db.AutoMigrate(&User{}, &Product{}, &Order{})

// 创建表时添加表后缀
db.Set("gorm:table_options", "ENGINE=InnoDB").AutoMigrate(&User{})
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付 49.00元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值