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. // Join Table: user_languages
  12. //   foreign key: user_id, reference: users.id
  13. //   foreign key: language_id, reference: languages.id

若要重写它们，可以使用标签 foreignKey、reference、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
  5. }
  7. type Profile struct {
  8.     gorm.Model
  9.     Name      string
  10.     UserRefer uint
  11. }
  13. // Which creates join table: user_profiles
  14. //   foreign key: user_refer_id, reference: users.refer
  15. //   foreign key: profile_refer, reference: profiles.user_refer

自引用 Many2Many

自引用 many2many 关系

  1. type User struct {
  2.   gorm.Model
  3.     Friends []*User `gorm:"many2many:user_friends"`
  4. }
  6. // Which creates join table: 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
  14.   AddressID int
  15.   CreatedAt time.Time
  16.   DeletedAt gorm.DeletedAt
  17. }
  19. func (PersonAddress) BeforeCreate(db *gorm.DB) error {
  20.   // ...
  21. }
  23. // PersonAddress 必须定义相关的的外键字段，否则会报错
  24. db.SetupJoinTable(&Person{}, "Addresses", &PersonAddress{})

外键约束

你可以通过标签 constraint 并带上 OnUpdate、OnDelete 实现外键约束，例如：

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

复合外键

如果您的模型使用了 复合主键，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.   SharedTags []Tag `gorm:"many2many:shared_blog_tags;ForeignKey:id;References:id"`
  14.   LocaleTags []Tag `gorm:"many2many:locale_blog_tags;ForeignKey:id,locale;References:id"`
  15. }
  17. // Join Table: 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. // Join Table: shared_blog_tags
  24. //   foreign key: blog_id, reference: blogs.id
  25. //   foreign key: tag_id, reference: tags.id
  27. // Join Table: locale_blog_tags
  28. //   foreign key: blog_id, reference: blogs.id
  29. //   foreign key: blog_locale, reference: blogs.locale
  30. //   foreign key: tag_id, reference: tags.id

还可以查看 复合主键