创建记录

1. user := User{Name: "Jinzhu", Age: 18, Birthday: time.Now()}

3. result := db.Create(&user) // 通过数据的指针来创建

5. user.ID             // 返回插入数据的主键
6. result.Error        // 返回 error
7. result.RowsAffected // 返回插入记录的条数

用指定的字段创建记录

创建记录并更新给出的字段。

1. db.Select("Name", "Age", "CreatedAt").Create(&user)
2. // INSERT INTO `users` (`name`,`age`,`created_at`) VALUES ("jinzhu", 18, "2020-07-04 11:05:21.775")

创建一个记录且一同忽略传递给略去的字段值。

1. db.Omit("Name", "Age", "CreatedAt").Create(&user)
2. // INSERT INTO `users` (`birthday`,`updated_at`) VALUES ("2020-01-01 00:00:00.000", "2020-07-04 11:05:21.775")

批量插入

要有效地插入大量记录，请将一个 slice 传递给 Create 方法。 GORM 将生成单独一条SQL语句来插入所有数据，并回填主键的值，钩子方法也会被调用。

1. var users = []User{{Name: "jinzhu1"}, {Name: "jinzhu2"}, {Name: "jinzhu3"}}
2. db.Create(&users)

4. for _, user := range users {
5. user.ID // 1,2,3
6. }

使用 CreateInBatches 分批创建时，你可以指定每批的数量，例如：

1. var users = []User{{name: "jinzhu_1"}, ...., {Name: "jinzhu_10000"}}

3. // 数量为 100
4. db.CreateInBatches(users, 100)

Upsert 和 Create With Associations 也支持批量插入

注意 使用CreateBatchSize 选项初始化 GORM 时，所有的创建& 关联 INSERT 都将遵循该选项

1. db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{
2. CreateBatchSize: 1000,
3. })

5. db := db.Session(&gorm.Session{CreateBatchSize: 1000})

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

9. db.Create(&users)
10. // INSERT INTO users xxx (5 batches)
11. // INSERT INTO pets xxx (15 batches)

创建钩子

GORM 允许用户定义的钩子有 BeforeSave, BeforeCreate, AfterSave, AfterCreate 创建记录时将调用这些钩子方法，请参考 Hooks 中关于生命周期的详细信息

1. func (u *User) BeforeCreate(tx *gorm.DB) (err error) {
2. u.UUID = uuid.New()

4. if u.Role == "admin" {
5. return errors.New("invalid role")
6. }
7. return
8. }

如果您想跳过 钩子 方法，您可以使用 SkipHooks 会话模式，例如：

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

3. DB.Session(&gorm.Session{SkipHooks: true}).Create(&users)

5. DB.Session(&gorm.Session{SkipHooks: true}).CreateInBatches(users, 100)

根据 Map 创建

GORM 支持根据 map[string]interface{} 和 []map[string]interface{}{} 创建记录，例如：

1. db.Model(&User{}).Create(map[string]interface{}{
2. "Name": "jinzhu", "Age": 18,
3. })

5. // batch insert from `[]map[string]interface{}{}`
6. db.Model(&User{}).Create([]map[string]interface{}{
7. {"Name": "jinzhu_1", "Age": 18},
8. {"Name": "jinzhu_2", "Age": 20},
9. })

注意： 根据 map 创建记录时，association 不会被调用，且主键也不会自动填充

使用 SQL 表达式、Context Valuer 创建记录

GORM 允许使用 SQL 表达式插入数据，有两种方法实现这个目标。根据 map[string]interface{} 或 自定义数据类型 创建，例如：

1. // 通过 map 创建记录
2. db.Model(User{}).Create(map[string]interface{}{
3. "Name": "jinzhu",
4. "Location": clause.Expr{SQL: "ST_PointFromText(?)", Vars: []interface{}{"POINT(100 100)"}},
5. })
6. // INSERT INTO `users` (`name`,`location`) VALUES ("jinzhu",ST_PointFromText("POINT(100 100)"));

8. // 通过自定义类型创建记录
9. type Location struct {
10. X, Y int
11. }

13. // Scan 方法实现了 sql.Scanner 接口
14. func (loc *Location) Scan(v interface{}) error {
15. // Scan a value into struct from database driver
16. }

18. func (loc Location) GormDataType() string {
19. return "geometry"
20. }

22. func (loc Location) GormValue(ctx context.Context, db *gorm.DB) clause.Expr {
23. return clause.Expr{
24. SQL:  "ST_PointFromText(?)",
25. Vars: []interface{}{fmt.Sprintf("POINT(%d %d)", loc.X, loc.Y)},
26. }
27. }

29. type User struct {
30. Name     string
31. Location Location
32. }

34. db.Create(&User{
35. Name:     "jinzhu",
36. Location: Location{X: 100, Y: 100},
37. })
38. // INSERT INTO `users` (`name`,`location`) VALUES ("jinzhu",ST_PointFromText("POINT(100 100)"))

高级选项

关联创建

创建关联数据时，如果关联值是非零值，这些关联会被 upsert，且它们的 Hook 方法也会被调用

1. type CreditCard struct {
2. gorm.Model
3. Number   string
4. UserID   uint
5. }

7. type User struct {
8. gorm.Model
9. Name       string
10. CreditCard CreditCard
11. }

13. db.Create(&User{
14. Name: "jinzhu",
15. CreditCard: CreditCard{Number: "411111111111"}
16. })
17. // INSERT INTO `users` ...
18. // INSERT INTO `credit_cards` ...

您也可以通过 Select、 Omit 跳过关联保存，例如：

1. db.Omit("CreditCard").Create(&user)

3. // 跳过所有关联
4. db.Omit(clause.Associations).Create(&user)

默认值

您可以通过标签 default 为字段定义默认值，如：

1. type User struct {
2. ID   int64
3. Name string `gorm:"default:galeone"`
4. Age  int64  `gorm:"default:18"`
5. }

插入记录到数据库时，默认值 会被用于 填充值为 零值 的字段

注意 对于声明了默认值的字段，像 0、''、false 等零值是不会保存到数据库。您需要使用指针类型或 Scanner/Valuer 来避免这个问题，例如：

1. type User struct {
2. gorm.Model
3. Name string
4. Age  *int           `gorm:"default:18"`
5. Active sql.NullBool `gorm:"default:true"`
6. }

注意 若要数据库有默认、虚拟/生成的值，你必须为字段设置 default 标签。若要在迁移时跳过默认值定义，你可以使用 default:(-)，例如：

1. type User struct {
2. ID        string `gorm:"default:uuid_generate_v3()"` // db func
3. FirstName string
4. LastName  string
5. Age       uint8
6. FullName  string `gorm:"->;type:GENERATED ALWAYS AS (concat(firstname,' ',lastname));default:(-);"`
7. }

使用虚拟/生成的值时，你可能需要禁用它的创建、更新权限，查看 字段级权限 获取详情

Upsert 及冲突

GORM 为不同数据库提供了兼容的 Upsert 支持

1. import "gorm.io/gorm/clause"

3. // 在冲突时，什么都不做
4. db.Clauses(clause.OnConflict{DoNothing: true}).Create(&user)

6. // 在`id`冲突时，将列更新为默认值
7. db.Clauses(clause.OnConflict{
8. Columns:   []clause.Column{{Name: "id"}},
9. DoUpdates: clause.Assignments(map[string]interface{}{"role": "user"}),
10. }).Create(&users)
11. // MERGE INTO "users" USING *** WHEN NOT MATCHED THEN INSERT *** WHEN MATCHED THEN UPDATE SET ***; SQL Server
12. // INSERT INTO `users` *** ON DUPLICATE KEY UPDATE ***; MySQL

14. // 使用SQL语句
15. db.Clauses(clause.OnConflict{
16. Columns:   []clause.Column{{Name: "id"}},
17. DoUpdates: clause.Assignments(map[string]interface{}{"count": gorm.Expr("GREATEST(count, VALUES(count))")}),
18. }).Create(&users)
19. // INSERT INTO `users` *** ON DUPLICATE KEY UPDATE `count`=GREATEST(count, VALUES(count));

21. // 在`id`冲突时，将列更新为新值
22. db.Clauses(clause.OnConflict{
23. Columns:   []clause.Column{{Name: "id"}},
24. DoUpdates: clause.AssignmentColumns([]string{"name", "age"}),
25. }).Create(&users)
26. // MERGE INTO "users" USING *** WHEN NOT MATCHED THEN INSERT *** WHEN MATCHED THEN UPDATE SET "name"="excluded"."name"; SQL Server
27. // INSERT INTO "users" *** ON CONFLICT ("id") DO UPDATE SET "name"="excluded"."name", "age"="excluded"."age"; PostgreSQL
28. // INSERT INTO `users` *** ON DUPLICATE KEY UPDATE `name`=VALUES(name),`age=VALUES(age); MySQL

30. // 在冲突时，更新除主键以外的所有列到新值。
31. db.Clauses(clause.OnConflict{
32. UpdateAll: true,
33. }).Create(&users)
34. // INSERT INTO "users" *** ON CONFLICT ("id") DO UPDATE SET "name"="excluded"."name", "age"="excluded"."age", ...;

您还可以查看 高级查询 中的 FirstOrInit、FirstOrCreate

查看 原生 SQL 及构造器 获取更多细节