Many To Many

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

例如，您的应用包含了 user 和 language，且一个 user 可以说多种 language，多个 user 也可以说一种 language。

1. // User 拥有并属于多种 language，`user_languages` 是连接表
2. type User struct {
3. gorm.Model
4. Languages []Language `gorm:"many2many:user_languages;"`
5. }

7. type Language struct {
8. gorm.Model
9. Name string
10. }

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

反向引用

1. // User 拥有并属于多种 language，`user_languages` 是连接表
2. type User struct {
3. gorm.Model
4. Languages []*Language `gorm:"many2many:user_languages;"`
5. }

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

重写外键

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

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

6. type Language struct {
7. gorm.Model
8. Name string
9. }

11. // 连接表：user_languages
12. //   foreign key: user_id, reference: users.id
13. //   foreign key: language_id, reference: languages.id

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

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

7. type Profile struct {
8. gorm.Model
9. Name      string
10. UserRefer uint `gorm:"index:,unique"`
11. }

13. // 会创建连接表：user_profiles
14. //   foreign key: user_refer_id, reference: users.refer
15. //   foreign key: profile_refer, reference: profiles.user_refer

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

自引用 Many2Many

自引用 many2many 关系

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

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

预加载

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

Many2Many 的 CURD

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

自定义连接表

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

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

1. type Person struct {
2. ID        int
3. Name      string
4. Addresses []Address `gorm:"many2many:person_addresses;"`
5. }

7. type Address struct {
8. ID   uint
9. Name string
10. }

12. type PersonAddress struct {
13. PersonID  int `gorm:"primaryKey"`
14. AddressID int `gorm:"primaryKey"`
15. CreatedAt time.Time
16. DeletedAt gorm.DeletedAt
17. }

19. func (PersonAddress) BeforeCreate(db *gorm.DB) error {
20. // ...
21. }

23. // 修改 Person 的 Addresses 字段的连接表为 PersonAddress
24. // PersonAddress 必须定义好所需的外键，否则会报错
25. err := db.SetupJoinTable(&Person{}, "Addresses", &PersonAddress{})

外键约束

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

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

6. type Language struct {
7. Code string `gorm:"primarykey"`
8. Name string
9. }

11. // 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 会默认启用复合外键。

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

1. type Tag struct {
2. ID     uint   `gorm:"primaryKey"`
3. Locale string `gorm:"primaryKey"`
4. Value  string
5. }

7. type Blog struct {
8. ID         uint   `gorm:"primaryKey"`
9. Locale     string `gorm:"primaryKey"`
10. Subject    string
11. Body       string
12. Tags       []Tag `gorm:"many2many:blog_tags;"`
13. LocaleTags []Tag `gorm:"many2many:locale_blog_tags;ForeignKey:id,locale;References:id"`
14. SharedTags []Tag `gorm:"many2many:shared_blog_tags;ForeignKey:id;References:id"`
15. }

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

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

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

查看 复合主键 获取详情