gorm深入浅出（下）

gorm原生SQL和SQL 构建器

原生 SQL

原生查询 SQL 和 Scan

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)

Exec 原生 SQL

db.Exec("DROP TABLE users")
db.Exec("UPDATE orders SET shipped_at = ? WHERE id IN ?", time.Now(), []int64{1, 2, 3})

// Exec with SQL Expression
db.Exec("UPDATE users SET money = ? WHERE name = ?", gorm.Expr("money * ? + ?", 10000, 1), "jinzhu")

注意 GORM 允许缓存预编译 SQL 语句来提高性能，查看性能获取详情

命名参数

GORM 支持 sql.NamedArg、map[string]interface{}{} 或 struct 形式的命名参数，例如：

db.Where("name1 = @name OR name2 = @name", sql.Named("name", "jinzhu")).Find(&user)
// SELECT * FROM `users` WHERE name1 = "jinzhu" OR name2 = "jinzhu"

db.Where("name1 = @name OR name2 = @name", map[string]interface{}{"name": "jinzhu2"}).First(&result3)
// SELECT * FROM `users` WHERE name1 = "jinzhu2" OR name2 = "jinzhu2" ORDER BY `users`.`id` LIMIT 1

// 原生 SQL 及命名参数
db.Raw("SELECT * FROM users WHERE name1 = @name OR name2 = @name2 OR name3 = @name",
  sql.Named("name", "jinzhu1"), sql.Named("name2", "jinzhu2")).Find(&user)
// SELECT * FROM users WHERE name1 = "jinzhu1" OR name2 = "jinzhu2" OR name3 = "jinzhu1"

db.Exec("UPDATE users SET name1 = @name, name2 = @name2, name3 = @name",
  sql.Named("name", "jinzhunew"), sql.Named("name2", "jinzhunew2"))
// UPDATE users SET name1 = "jinzhunew", name2 = "jinzhunew2", name3 = "jinzhunew"

db.Raw("SELECT * FROM users WHERE (name1 = @name AND name3 = @name) AND name2 = @name2",
  map[string]interface{}{"name": "jinzhu", "name2": "jinzhu2"}).Find(&user)
// SELECT * FROM users WHERE (name1 = "jinzhu" AND name3 = "jinzhu") AND name2 = "jinzhu2"

type NamedArgument struct {
   Name string
   Name2 string
}

db.Raw("SELECT * FROM users WHERE (name1 = @Name AND name3 = @Name) AND name2 = @Name2",
    NamedArgument{Name: "jinzhu", Name2: "jinzhu2"}).Find(&user)
// SELECT * FROM users WHERE (name1 = "jinzhu" AND name3 = "jinzhu") AND name2 = "jinzhu2"

DryRun 模式

GenerateSQL及其参数不执行，可用于准备或测试生成的 SQL，Checkout Session了解详情

stmt := db.Session(&Session{DryRun: true}).First(&user, 1).Statement
stmt.SQL.String() //=> SELECT * FROM `users` WHERE `id` = $1 ORDER BY `id`
stmt.Vars         //=> []interface{}{1}

ToSQL

返回生成SQL而不执行。

GORM使用database/sql的参数占位符来构造SQL语句，会自动转义参数以避免SQL注入，但生成的SQL不提供安全保证，请仅用于调试。

sql := DB.ToSQL(func(tx *gorm.DB) *gorm.DB {
 return tx.Model(&User{}).Where("id = ?", 100).Limit(10).Order("age desc").Find(&[]User{})
})
sql //=> SELECT * FROM "users" WHERE id = 100 AND "users"."deleted_at" IS NULL ORDER BY age desc LIMIT 10

`Row` & `Rows`

得到结果为 *sql.Row

func testRaw2() {
	var name string
	var age int
	row := db.Table("users").Where("name=?", "tom").Select("name", "age").Row()
	// 把查出来的name age赋值给变量name age
	row.Scan(&name, &age)
	fmt.Printf("name: %v\n", name)
	fmt.Printf("age: %v\n", age)
}

得到结果为 *sql.Rows

// Use GORM API build SQL
var name string 
var age int
rows, err := db.Model(&User{}).Where("age > ?", "20").Select("name, age").Rows()
defer rows.Close()
for rows.Next() {
 rows.Scan(&name, &age)

 // do something
}

// Raw SQL
rows, err := db.Raw("select name, age, email from users where name = ?", "jinzhu").Rows()
defer rows.Close()
for rows.Next() {
 rows.Scan(&name, &age, &email)

 // do something
}

Checkout FindInBatches了解如何批量查询和处理记录 Checkout Group 条件，了解如何构建复杂的 SQL 查询

扫描`*sql.Rows`到结构体

用于ScanRows将行扫描到结构中，例如：

rows, err := db.Model(&User{}).Where("name = ?", "jinzhu").Select("name, age, email").Rows() // (*sql.Rows, error)
defer rows.Close()

var user User
for rows.Next() {
 // ScanRows scan a row into user
 db.ScanRows(rows, &user)

 // do something
}

高级

子句（Clause）

GORM使用SQL生成器生成SQL内部，对于每个操作，GORM创建一个*gorm.Statement对象，所有的API GORM添加/改变Clause为Statement基于这些条款，最后，GORM生成的SQL

例如，当查询 with 时First，它将以下子句添加到Statement

clause.Select{Columns: "*"}
clause.From{Tables: clause.CurrentTable}
clause.Limit{Limit: 1}
clause.OrderByColumn{
 Column: clause.Column{Table: clause.CurrentTable, Name: clause.PrimaryKey},
}

然后 GORM 构建最终在Query回调中查询 SQL，例如：

Statement.Build("SELECT", "FROM", "WHERE", "GROUP BY", "ORDER BY", "LIMIT", "FOR")

其中生成 SQL：

SELECT * FROM `users` ORDER BY `users`.`id` LIMIT 1

您可以定义自己的Clause并与 GORM 一起使用，它需要实现Interface

查看示例以供参考

子句构造器

对于不同的数据库，Clauses 可能会生成不同的 SQL，例如：

db.Offset(10).Limit(5).Find(&users)
// Generated for SQL Server
// SELECT * FROM "users" OFFSET 10 ROW FETCH NEXT 5 ROWS ONLY
// Generated for MySQL
// SELECT * FROM `users` LIMIT 5 OFFSET 10

支持是因为GORM允许数据库驱动注册Clause Builder来代替默认的，以Limit为例

子句选项

GORM 定义了许多子句，并且一些子句提供了可用于您的应用程序的高级选项

虽然它们中的大多数很少使用，但如果您发现 GORM 公共 API 不能满足您的要求，可以查看它们，例如：

db.Clauses(clause.Insert{Modifier: "IGNORE"}).Create(&user)
// INSERT IGNORE INTO users (name,age...) VALUES ("jinzhu",18...);

语句修饰符

GORM 提供接口StatementModifier允许您修改语句以符合您的要求，以Hints为例

import "gorm.io/hints"

db.Clauses(hints.New("hint")).Find(&User{})
// SELECT * /*+ hint */ FROM `users`

gorm关联关系Belongs To（属于）

Belongs To

belongs to 会与另一个模型建立了一对一的连接。这种模型的每一个实例都“属于”另一个模型的一个实例。

例如，您的应用包含 user 和 company，并且每个 user 能且只能被分配给一个 company。下面的类型就表示这种关系。注意，在 User 对象中，有一个和 Company 一样的 CompanyID。默认情况下， CompanyID 被隐含地用来在 User 和 Company 之间创建一个外键关系，因此必须包含在 User 结构体中才能填充 Company 内部结构体。

...

var db *gorm.DB

func init() {
	...
}

func main() {
	type Company struct {
		ID   int
		Name string
	}

	type User struct {
		gorm.Model
		Name string
		// 下面两句会给User生成外键CompanyID
		CompanyID int
		Company   Company
	}

	db.AutoMigrate(&Company{}, &User{})
}

请参阅预加载以了解内部结构的详细信息。

重写外键

要定义一个 belongs to 关系，数据库的表中必须存在外键。默认情况下，外键的名字，使用拥有者的类型名称加上表的主键的字段名字

例如，定义一个User实体属于Company实体，那么外键的名字一般使用CompanyID。

GORM同时提供自定义外键名字的方式，如下例所示。

type User struct {
gorm.Model
Name         string
CompanyRefer int
Company     Company `gorm:"foreignKey:CompanyRefer"`
// 使用 CompanyRefer 作为外键
}

type Company struct {
ID   int
Name string
}

重写引用

对于 belongs to 关系，GORM 通常使用数据库表，主表（拥有者）的主键值作为外键参考。正如上面的例子，我们使用主表Company中的主键字段ID作为外键的参考值。

如果在Company实体中设置了User实体，那么GORM会自动把Company中的ID属性保存到User的CompanyID属性中。

同样的，您也可以使用标签 references 来更改它，例如：

type User struct {
gorm.Model
Name     string
CompanyID string
Company   Company `gorm:"references:Code"` // 使用 Code 作为引用
}

type Company struct {
ID   int
Code string
Name string
}

Belongs to 的 CRUD

点击关联模式链接获取 belongs to 相关的用法

预加载

GORM允许通过使用Preload或者Joins来主动加载实体的关联关系，具体内容请参考，预加载（主动加载）

外键约束

你可以通过OnUpdate, OnDelete配置标签来增加关联关系的级联操作，如下面的例子，通过GORM可以完成用户和公司的级联更新和级联删除操作：

type User struct {
gorm.Model
Name     string
CompanyID int
Company   Company `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
}

type Company struct {
ID   int
Name string
}

gorm关联关系之Has One（有一个）

Has One

has one 与另一个模型建立一对一的关联，但它和一对一关系有些许不同。这种关联表明一个模型的每个实例都包含或拥有另一个模型的一个实例。

例如，您的应用包含 user 和 credit card 模型，且每个 user 只能有一张 credit card。

...

func init() {
	...
}

func main() {
	type CreditCard struct {
		gorm.Model
		Number string
		// UserID会自动与User关联
		UserID uint
	}

	type User struct {
		gorm.Model
		CreditCard CreditCard
	}

	db.AutoMigrate(&User{}, &CreditCard{})
}

重写外键

对于 has one 关系，同样必须存在外键字段。拥有者将把属于它的模型的主键保存到这个字段。

这个字段的名称通常由 has one 模型的类型加上其 主键 生成，对于上面的例子，它是 UserID。

为 user 添加 credit card 时，它会将 user 的 ID 保存到自己的 UserID 字段。

如果你想要使用另一个字段来保存该关系，你同样可以使用标签 foreignKey 来更改它，例如：

type User struct {
 gorm.Model
 CreditCard CreditCard `gorm:"foreignKey:UserName"`
 // 使用 UserName 作为外键
}

type CreditCard struct {
 gorm.Model
 Number   string
 UserName string
}

重写引用

默认情况下，拥有者实体会将 has one 对应模型的主键保存为外键，您也可以修改它，用另一个字段来保存，例如下个这个使用 Name 来保存的例子。

您可以使用标签 references 来更改它，例如：

type User struct {
 gorm.Model
 Name       string     `gorm:"index"`
 CreditCard CreditCard `gorm:"foreignkey:UserName;references:name"`
}

type CreditCard struct {
 gorm.Model
 Number   string
 UserName string
}

多态关联

GORM 为 has one 和 has many 提供了多态关联支持，它会将拥有者实体的表名、主键值都保存到多态类型的字段中。

...

func init() {
	...
}

type Toy struct {
	ID        int
	Name      string
	OwnerID   int
	OwnerType string
}

type Cat struct {
	ID   int
	Name string
	Toy  Toy `gorm:"polymorphic:Owner;"`
}

type Dog struct {
	ID   int
	Name string
	Toy  Toy `gorm:"polymorphic:Owner;"`
}

func test2() {
	db.AutoMigrate(&Toy{}, &Cat{}, &Dog{})
}

func test3() {
	// db.Create(&Dog{Name: "dog1", Toy: Toy{Name: "toy1"}})
	db.Create(&Cat{Name: "cat1", Toy: Toy{Name: "toy2"}})
}

func main() {
	// test2()
	test3()
}

您可以使用标签 polymorphicValue 来更改多态类型的值，例如：

type Dog struct {
 ID   int
 Name string
 Toy  Toy `gorm:"polymorphic:Owner;polymorphicValue:master"`
}

type Toy struct {
 ID        int
 Name      string
 OwnerID   int
 OwnerType string
}

db.Create(&Dog{Name: "dog1", Toy: Toy{Name: "toy1"}})
// INSERT INTO `dogs` (`name`) VALUES ("dog1")
// INSERT INTO `toys` (`name`,`owner_id`,`owner_type`) VALUES ("toy1","1","master")

Has One 的 CURD

查看关联模式获取 has one 相关的用法

预加载

GORM 可以通过 Preload、Joins 预加载 has one 关联的记录，查看预加载获取详情

自引用 Has One

type User struct {
 gorm.Model
 Name      string
 ManagerID *uint
 Manager   *User
}

外键约束

你可以通过为标签 constraint 配置 OnUpdate、OnDelete 实现外键约束，在使用 GORM 进行迁移时它会被创建，例如：

type User struct {
 gorm.Model
 CreditCard CreditCard `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
}

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

你也可以在删除记录时通过 Select 来删除关联的记录，查看 Delete with Select 获取详情

gorm关联关系之Has Many

Has Many

has many 与另一个模型建立了一对多的连接。不同于 has one，拥有者可以有零或多个关联模型。

例如，您的应用包含 user 和 credit card 模型，且每个 user 可以有多张 credit card。

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

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

重写外键

要定义 has many 关系，同样必须存在外键。默认的外键名是拥有者的类型名加上其主键字段名

例如，要定义一个属于 User 的模型，则其外键应该是 UserID。

此外，想要使用另一个字段作为外键，您可以使用 foreignKey 标签自定义它：

type User struct {
 gorm.Model
 CreditCards []CreditCard `gorm:"foreignKey:UserRefer"`
}

type CreditCard struct {
 gorm.Model
 Number    string
 UserRefer uint
}

重写引用

GORM 通常使用拥有者的主键作为外键的值。对于上面的例子，它是 User 的 ID 字段。

为 user 添加 credit card 时，GORM 会将 user 的 ID 字段保存到 credit card 的 UserID 字段。

同样的，您也可以使用标签 references 来更改它，例如：

type User struct {
 gorm.Model
 MemberNumber string
 CreditCards []CreditCard `gorm:"foreignKey:UserNumber;references:MemberNumber"`
}

type CreditCard struct {
 gorm.Model
 Number     string
 UserNumber string
}

多态关联

GORM 为 has one 和 has many 提供了多态关联支持，它会将拥有者实体的表名、主键都保存到多态类型的字段中。

type Dog struct {
 ID   int
 Name string
 Toys []Toy `gorm:"polymorphic:Owner;"`
}

type Toy struct {
 ID        int
 Name      string
 OwnerID   int
 OwnerType string
}

db.Create(&Dog{Name: "dog1", Toys: []Toy{{Name: "toy1"}, {Name: "toy2"}}})
// INSERT INTO `dogs` (`name`) VALUES ("dog1")
// INSERT INTO `toys` (`name`,`owner_id`,`owner_type`) VALUES ("toy1","1","dogs"), ("toy2","1","dogs")

您可以使用标签 polymorphicValue 来更改多态类型的值，例如：

type Dog struct {
 ID   int
 Name string
 Toys []Toy `gorm:"polymorphic:Owner;polymorphicValue:master"`
}

type Toy struct {
 ID        int
 Name      string
 OwnerID   int
 OwnerType string
}

db.Create(&Dog{Name: "dog1", Toys: []Toy{{Name: "toy1"}, {Name: "toy2"}}})
// INSERT INTO `dogs` (`name`) VALUES ("dog1")
// INSERT INTO `toys` (`name`,`owner_id`,`owner_type`) VALUES ("toy1","1","master"), ("toy2","1","master")

Has Many 的 CURD

查看关联模式获取 has many 相关的用法

预加载

GORM 可以通过 Preload 预加载 has many 关联的记录，查看预加载获取详情

自引用 Has Many

type User struct {
 gorm.Model
 Name      string
 ManagerID *uint
 Team     []User `gorm:"foreignkey:ManagerID"`
}

外键约束

你可以通过为标签 constraint 配置 OnUpdate、OnDelete 实现外键约束，在使用 GORM 进行迁移时它会被创建，例如：

type User struct {
 gorm.Model
 CreditCards []CreditCard `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
}

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

你也可以在删除记录时通过 Select 来删除 has many 关联的记录，查看 Delete with Select 获取详情

gorm关联关系之Many To Many

Many To Many

Many to Many 会在两个 model 中添加一张连接表。

例如，您的应用包含了 user 和 language，且一个 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
}

db.AutoMigrate(&User{}, &Language{})

func insert(){
    l := Language{
        Name: "english",
    }
    
    l2 := Language{
        Name: "chinese",
    }
    
    user := User{
        Languages: []Language{l, l2},
    }
    
    db.Create(&l)
    db.Create()&user)
}

当使用 GORM 的 AutoMigrate 为 User 创建表时，GORM 会自动创建连接表

反向引用

// 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;"`
}

重写外键

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

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

type Language struct {
 gorm.Model
 Name string
}

// Join Table: user_languages
//   foreign key: user_id, reference: users.id
//   foreign key: language_id, reference: languages.id

若要重写它们，可以使用标签 foreignKey、references、joinforeignKey、joinReferences。当然，您不需要使用全部的标签，你可以仅使用其中的一个重写部分的外键、引用。

type User struct {
   gorm.Model
   Profiles []Profile `gorm:"many2many:user_profiles;foreignKey:Refer;joinForeignKey:UserReferID;References:UserRefer;joinReferences:ProfileRefer"`
   Refer    uint      `gorm:"index:,unique"`
}

type Profile struct {
   gorm.Model
   Name      string
   UserRefer uint `gorm:"index:,unique"`
}

// Which creates join table: user_profiles
//   foreign key: user_refer_id, reference: users.refer
//   foreign key: profile_refer, reference: profiles.user_refer

注意： 某些数据库只允许在唯一索引字段上创建外键，如果您在迁移时会创建外键，则需要指定 unique index 标签。

自引用 Many2Many

自引用 many2many 关系

type User struct {
 gorm.Model
   Friends []*User `gorm:"many2many:user_friends"`
}

// 会创建连接表：user_friends
//   foreign key: user_id, reference: users.id
//   foreign key: friend_id, reference: users.id

预加载

GORM 可以通过 Preload 预加载 has many 关联的记录，查看预加载获取详情

Many2Many 的 CURD

查看关联模式获取 many2many 相关的用法

自定义连接表

连接表 可以是一个全功能的模型，支持 Soft Delete、钩子、更多的字段，就跟其它模型一样。您可以通过 SetupJoinTable 指定它，例如：

注意： 自定义连接表要求外键是复合主键或复合唯一索引

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{})

外键约束

你可以通过为标签 constraint 配置 OnUpdate、OnDelete 实现外键约束，在使用 GORM 进行迁移时它会被创建，例如：

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

type Language struct {
 Code string `gorm:"primarykey"`
 Name string
}

// CREATE TABLE `user_speaks` (`user_id` integer,`language_code` text,PRIMARY KEY (`user_id`,`language_code`),CONSTRAINT `fk_user_speaks_user` FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON DELETE SET NULL ON UPDATE CASCADE,CONSTRAINT `fk_user_speaks_language` FOREIGN KEY (`language_code`) REFERENCES `languages`(`code`) ON DELETE SET NULL ON UPDATE CASCADE);

你也可以在删除记录时通过 Select 来删除 many2many 关系的记录，查看 Delete with Select 获取详情

复合外键

如果您的模型使用了复合主键，GORM 会默认启用复合外键。

您也可以覆盖默认的外键、指定多个外键，只需用逗号分隔那些键名，例如：

type Tag struct {
 ID     uint   `gorm:"primaryKey"`
 Locale string `gorm:"primaryKey"`
 Value  string
}

type Blog struct {
 ID         uint   `gorm:"primaryKey"`
 Locale     string `gorm:"primaryKey"`
 Subject    string
 Body       string
 Tags       []Tag `gorm:"many2many:blog_tags;"`
 LocaleTags []Tag `gorm:"many2many:locale_blog_tags;ForeignKey:id,locale;References:id"`
 SharedTags []Tag `gorm:"many2many:shared_blog_tags;ForeignKey:id;References:id"`
}

// 连接表：blog_tags
//   foreign key: blog_id, reference: blogs.id
//   foreign key: blog_locale, reference: blogs.locale
//   foreign key: tag_id, reference: tags.id
//   foreign key: tag_locale, reference: tags.locale

// 连接表：locale_blog_tags
//   foreign key: blog_id, reference: blogs.id
//   foreign key: blog_locale, reference: blogs.locale
//   foreign key: tag_id, reference: tags.id

// 连接表：shared_blog_tags
//   foreign key: blog_id, reference: blogs.id
//   foreign key: tag_id, reference: tags.id

查看复合主键获取详情

gorm关联关系之实体关联

自动创建、更新

在创建、更新记录时，GORM 会通过 Upsert 自动保存关联及其引用记录。

...

func init() {
	...
}

type Email struct {
	gorm.Model
	Email  string
	UserID uint
}

// User拥有并属于多种Language 使用 user_languages 连接表
type User struct {
	gorm.Model
	Name            string
	BillingAddress  Address
	ShippingAddress Address
	Emails          []Email
	Languages       []Language `gorm:"many2many:user_languages;"`
}

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

type Address struct {
	gorm.Model
	Address1 string
	UserID   uint
}

func create() {
	db.AutoMigrate(&User{}, &Email{}, &Address{}, &Language{})
}

func test1() {
	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)
// BEGIN TRANSACTION;
// INSERT INTO "addresses" (address1) VALUES ("Billing Address - Address 1"), ("Shipping Address - Address 1") ON DUPLICATE KEY DO NOTHING;
// 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"), (111, "jinzhu-2@example.com") ON DUPLICATE KEY DO NOTHING;
// INSERT INTO "languages" ("name") VALUES ('ZH'), ('EN') ON DUPLICATE KEY DO NOTHING;
// INSERT INTO "user_languages" ("user_id","language_id") VALUES (111, 1), (111, 2) ON DUPLICATE KEY DO NOTHING;
// COMMIT;

        db.Save(&user)
}

func main() {
	// create()
	test1()
}

如果您想要更新关联的数据，您应该使用 FullSaveAssociations 模式：

db.Session(&gorm.Session{FullSaveAssociations: true}).Updates(&user)
// ...
// INSERT INTO "addresses" (address1) VALUES ("Billing Address - Address 1"), ("Shipping Address - Address 1") ON DUPLICATE KEY SET address1=VALUES(address1);
// 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"), (111, "jinzhu-2@example.com") ON DUPLICATE KEY SET email=VALUES(email);
// ...

跳过自动创建、更新

若要在创建、更新时跳过自动保存，您可以使用 Select 或 Omit，例如：

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.Select("Name").Create(&user)
// INSERT INTO "users" (name) VALUES ("jinzhu", 1, 2);

db.Omit("BillingAddress").Create(&user)
// Skip create BillingAddress when creating a user

// 忽略所有的关联子句 只加user
db.Omit(clause.Associations).Create(&user)
// Skip all associations when creating a user

NOTE: 对于 many2many 关联，GORM 在创建连接表引用之前，会先 upsert 关联。如果你想跳过关联的 upsert，你可以这样做：
db.Omit("Languages.*").Create(&user)
下面的代码将跳过创建关联及其引用
db.Omit("Languages").Create(&user)

Select/Omit 关联字段

user := User{
 Name:            "jinzhu",
 BillingAddress:  Address{Address1: "Billing Address - Address 1", Address2: "addr2"},
 ShippingAddress: Address{Address1: "Shipping Address - Address 1", Address2: "addr2"},
}

// 创建 user 及其 BillingAddress、ShippingAddress
// 在创建 BillingAddress 时，仅使用其 address1、address2 字段，忽略其它字段
db.Select("BillingAddress.Address1", "BillingAddress.Address2").Create(&user)

// Omit忽略
db.Omit("BillingAddress.Address2", "BillingAddress.CreatedAt").Create(&user)

关联模式

关联模式包含一些在处理关系时有用的方法

// 开始关联模式
var user User
db.Model(&user).Association("Languages")
// `user` 是源模型，它的主键不能为空
// 关系的字段名是 `Languages`
// 如果匹配了上面两个要求，会开始关联模式，否则会返回错误
db.Model(&user).Association("Languages").Error

查找关联

查找所有匹配的关联记录

func test2() {
	var user User
	db.First(&user)
	var languages []Language
	db.Model(&user).Association("Languages").Find(&languages)
	fmt.Printf("languages: %v\n", languages)
}

查找带条件的关联

codes := []string{"zh-CN", "en-US", "ja-JP"}
db.Model(&user).Where("code IN ?", codes).Association("Languages").Find(&languages)

db.Model(&user).Where("code IN ?", codes).Order("code desc").Association("Languages").Find(&languages)

添加关联

为 many to many、has many 添加新的关联；为 has one, belongs to 替换当前的关联

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

db.Model(&user).Association("Languages").Append(&Language{Name: "DE"})

db.Model(&user).Association("CreditCard").Append(&CreditCard{Number: "411111111111"})

替换关联

用一个新的关联替换当前的关联

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()

// 条件计数
codes := []string{"zh-CN", "en-US", "ja-JP"}
db.Model(&user).Where("code IN ?", codes).Association("Languages").Count()

批量处理数据

关联模式也支持批量处理，例如：

// 查询所有用户的所有角色
db.Model(&users).Association("Role").Find(&roles)

// 从所有 team 中删除 user A
db.Model(&users).Association("Team").Delete(&userA)

// 获取去重的用户所属 team 数量
db.Model(&users).Association("Team").Count()

// 对于批量数据的 `Append`、`Replace`，参数的长度必须与数据的长度相同，否则会返回 error
var users = []User{user1, user2, user3}
// 例如：现在有三个 user，Append userA 到 user1 的 team，Append userB 到 user2 的 team，Append userA、userB 和 userC 到 user3 的 team
db.Model(&users).Association("Team").Append(&userA, &userB, &[]User{userA, userB, userC})
// 重置 user1 team 为 userA，重置 user2 的 team 为 userB，重置 user3 的 team 为 userA、 userB 和 userC
db.Model(&users).Association("Team").Replace(&userA, &userB, &[]User{userA, userB, userC})

带 Select 的删除

你可以在删除记录时通过 Select 来删除具有 has one、has many、many2many 关系的记录，例如：

// 删除 user 时，也删除 user 的 account
db.Select("Account").Delete(&user)

// 删除 user 时，也删除 user 的 Orders、CreditCards 记录
db.Select("Orders", "CreditCards").Delete(&user)

// 删除 user 时，也删除用户所有 has one/many、many2many 记录
db.Select(clause.Associations).Delete(&user)

// 删除 users 时，也删除每一个 user 的 account
db.Select("Account").Delete(&users)

注意： 只有当记录的主键不为空时，关联才会被删除，GORM 会使用这些主键作为条件来删除关联记录

// DOESN'T WORK
db.Select("Account").Where("name = ?", "jinzhu").Delete(&User{})
// 会删除所有 name=`jinzhu` 的 user，但这些 user 的 account 不会被删除

db.Select("Account").Where("name = ?", "jinzhu").Delete(&User{ID: 1})
// 会删除 name = `jinzhu` 且 id = `1` 的 user，并且 user `1` 的 account 也会被删除

db.Select("Account").Delete(&User{ID: 1})
// 会删除 id = `1` 的 user，并且 user `1` 的 account 也会被删除

关联标签

标签	描述
foreignKey	指定当前模型的列作为连接表的外键
references	指定引用表的列名，其将被映射为连接表外键
polymorphic	指定多态类型，比如模型名
polymorphicValue	指定多态值、默认表名
many2many	指定连接表表名
joinForeignKey	指定连接表的外键列名，其将被映射到当前表
joinReferences	指定连接表的外键列名，其将被映射到引用表
constraint	关系约束，例如：`OnUpdate`、`OnDelete`

gorm 会话

GORM 提供了 Session 方法，这是一个 New Session Method，它允许创建带配置的新建会话模式：

// Session 配置
type Session struct {
 DryRun                 bool
 PrepareStmt            bool
 NewDB                  bool
 SkipHooks              bool
 SkipDefaultTransaction bool
 AllowGlobalUpdate      bool
 FullSaveAssociations   bool
 Context                context.Context
 Logger                 logger.Interface
 NowFunc                func() time.Time
}

DryRun

生成 SQL 但不执行。它可以用于准备或测试生成的 SQL，例如：

// 新建会话模式
stmt := db.Session(&Session{DryRun: true}).First(&user, 1).Statement
stmt.SQL.String() //=> SELECT * FROM `users` WHERE `id` = $1 ORDER BY `id`
stmt.Vars         //=> []interface{}{1}

// 全局 DryRun 模式
db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{DryRun: true})

// 不同的数据库生成不同的 SQL
stmt := db.Find(&user, 1).Statement
stmt.SQL.String() //=> SELECT * FROM `users` WHERE `id` = $1 // PostgreSQL
stmt.SQL.String() //=> SELECT * FROM `users` WHERE `id` = ? // MySQL
stmt.Vars         //=> []interface{}{1}

你可以使用下面的代码生成最终的 SQL：

// 注意：SQL 并不总是能安全地执行，GORM 仅将其用于日志，它可能导致会 SQL 注入
db.Dialector.Explain(stmt.SQL.String(), stmt.Vars...)
// SELECT * FROM `users` WHERE `id` = 1

预编译

PreparedStmt 在执行任何 SQL 时都会创建一个 prepared statement 并将其缓存，以提高后续的效率，例如：

// 全局模式，所有 DB 操作都会创建并缓存预编译语句
db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{
 PrepareStmt: true,
})

// 会话模式
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() // 关闭预编译模式
}

NewDB

通过 NewDB 选项创建一个不带之前条件的新 DB，例如：

tx := db.Where("name = ?", "jinzhu").Session(&gorm.Session{NewDB: true})

tx.First(&user)
// SELECT * FROM users ORDER BY id LIMIT 1

tx.First(&user, "id = ?", 10)
// SELECT * FROM users WHERE id = 10 ORDER BY id

// 不带 `NewDB` 选项
tx2 := db.Where("name = ?", "jinzhu").Session(&gorm.Session{})
tx2.First(&user)
// SELECT * FROM users WHERE name = "jinzhu" ORDER BY id

跳过钩子

如果您想跳过 钩子 方法，您可以使用 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)

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

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

DB.Session(&gorm.Session{SkipHooks: true}).Model(User{}).Where("age > ?", 18).Updates(&user)

禁用嵌套事务

在一个 DB 事务中使用 Transaction 方法，GORM 会使用 SavePoint(savedPointName)，RollbackTo(savedPointName) 为你提供嵌套事务支持。你可以通过 DisableNestedTransaction 选项关闭它，例如：

db.Session(&gorm.Session{
 DisableNestedTransaction: true,
}).CreateInBatches(&users, 100)

AllowGlobalUpdate

GORM 默认不允许进行全局 update/delete，该操作会返回 ErrMissingWhereClause 错误。您可以通过将一个选项设置为 true 来启用它，例如：

db.Session(&gorm.Session{
 AllowGlobalUpdate: true,
}).Model(&User{}).Update("name", "jinzhu")
// UPDATE users SET `name` = "jinzhu"

FullSaveAssociations

在创建、更新记录时，GORM 会通过 Upsert 自动保存关联及其引用记录。如果您想要更新关联的数据，您应该使用 FullSaveAssociations 模式，例如：

db.Session(&gorm.Session{FullSaveAssociations: true}).Updates(&user)
// ...
// INSERT INTO "addresses" (address1) VALUES ("Billing Address - Address 1"), ("Shipping Address - Address 1") ON DUPLICATE KEY SET address1=VALUES(address1);
// 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"), (111, "jinzhu-2@example.com") ON DUPLICATE KEY SET email=VALUES(email);
// ...

Context

通过 Context 选项，您可以传入 Context 来追踪 SQL 操作，例如：

timeoutCtx, _ := context.WithTimeout(context.Background(), time.Second)
tx := db.Session(&Session{Context: timeoutCtx})

tx.First(&user) // 带 timeoutCtx 的查询
tx.Model(&user).Update("role", "admin") // 带 timeoutCtx 的更新

GORM 也提供了快捷调用方法 WithContext，其实现如下：

func (db *DB) WithContext(ctx context.Context) *DB {
 return db.Session(&Session{Context: ctx})
}

Logger

Gorm 允许使用 Logger 选项自定义内建 Logger，例如：

newLogger := logger.New(log.New(os.Stdout, "\r\n", log.LstdFlags),
             logger.Config{
               SlowThreshold: time.Second,
               LogLevel:      logger.Silent,
               Colorful:      false,
            })
db.Session(&Session{Logger: newLogger})

db.Session(&Session{Logger: logger.Default.LogMode(logger.Silent)})

查看 Logger 获取详情.

NowFunc

NowFunc 允许改变 GORM 获取当前时间的实现，例如：

db.Session(&Session{
 NowFunc: func() time.Time {
   return time.Now().Local()
},
})

Debug

Debug 只是将会话的 Logger 修改为调试模式的快捷方法，其实现如下：

func (db *DB) Debug() (tx *DB) {
 return db.Session(&Session{
   Logger:         db.Logger.LogMode(logger.Info),
})
}

QueryFields

Select by fields

db.Session(&gorm.Session{QueryFields: true}).Find(&user)
// SELECT `users`.`name`, `users`.`age`, ... FROM `users` // 带该选项
// SELECT * FROM `users` // 不带该选项

CreateBatchSize

Default batch size

users = [5000]User{{Name: "jinzhu", Pets: []Pet{pet1, pet2, pet3}}...}

db.Session(&gorm.Session{CreateBatchSize: 1000}).Create(&users)
// INSERT INTO users xxx (需 5 次)
// INSERT INTO pets xxx (需 15 次)

gorm 事务

禁用默认事务

为了确保数据一致性，GORM 会在事务里执行写入操作（创建、更新、删除）。如果没有这方面的要求，您可以在初始化时禁用它，这将获得大约 30%+ 性能提升。

// 全局禁用
db, err := gorm.Open(mysql.Open("gorm.db"), &gorm.Config{
 SkipDefaultTransaction: true,
})

// 持续会话模式
tx := db.Session(&Session{SkipDefaultTransaction: true})
tx.First(&user, 1)
tx.Find(&users)
tx.Model(&user).Update("Age", 18)

事务

要在事务中执行一系列操作，一般流程如下：

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

Control the transaction manually

Gorm supports calling transaction control functions (commit / rollback) directly, for example:

// 开始事务
tx := db.Begin()

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

// ...

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

// 否则，提交事务
tx.Commit()

一个特殊的示例

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
}

SavePoint、RollbackTo

GORM provides SavePoint, RollbackTo to save points and roll back to a savepoint, for example:

tx := db.Begin()
tx.Create(&user1)

tx.SavePoint("sp1")
tx.Create(&user2)
tx.RollbackTo("sp1") // Rollback user2

tx.Commit() // Commit user1

gorm深入浅出（下）

gorm深入浅出（下）

gorm原生SQL和SQL 构建器

原生 SQL

命名参数

DryRun 模式

ToSQL

Row & Rows

扫描*sql.Rows到结构体

高级

子句（Clause）

子句构造器

子句选项

语句修饰符

gorm关联关系Belongs To（属于）

Belongs To

重写外键

重写引用

Belongs to 的 CRUD

预加载

外键约束

gorm关联关系之Has One（有一个）

Has One

重写外键

重写引用

多态关联

Has One 的 CURD

预加载

自引用 Has One

外键约束

gorm关联关系之Has Many

Has Many

重写外键

重写引用

多态关联

Has Many 的 CURD

预加载

自引用 Has Many

外键约束

gorm关联关系之Many To Many

Many To Many

反向引用

重写外键

自引用 Many2Many

预加载

Many2Many 的 CURD

自定义连接表

外键约束

复合外键

gorm关联关系之实体关联

自动创建、更新

跳过自动创建、更新

Select/Omit 关联字段

关联模式

查找关联

添加关联

替换关联

删除关联

清空关联

关联计数

批量处理数据

带 Select 的删除

关联标签

gorm 会话

DryRun

预编译

NewDB

跳过钩子

禁用嵌套事务

AllowGlobalUpdate

FullSaveAssociations

Context

Logger

NowFunc

Debug

QueryFields

CreateBatchSize

gorm 事务

禁用默认事务

事务

`Row` & `Rows`

扫描`*sql.Rows`到结构体