GORM many2many、many2one、one2many关联表的操作

一、简单介绍：

　　当我们设计数据库时，经常会遇到实体之间的关系。这些关系通常可以分为三种类型：many-to-many（多对多）、many-to-one（多对一）和one-to-many（一对多）。

1. Many-to-Many (多对多):

   • 意义：多对多关系表示一个实体可以与多个其他实体相关联，同时这些实体也可以与多个该实体相关联。例如，学生和课程之间的关系。一个学生可以选修多门课程，而一门课程也可以被多个学生选修。
   • 示例：学生和课程之间的关系，一个学生可以选修多门课程，一门课程也可以被多个学生选修。

2. Many-to-One (多对一):

   • 意义：多对一关系表示多个实体可以与一个实体相关联，但是该实体只能与一个其他实体相关联。例如，订单和客户之间的关系。一个客户可以有多个订单，但一个订单只能属于一个客户。
   • 示例：订单和客户之间的关系，一个客户可以有多个订单，但是一个订单只能属于一个客户。

3. One-to-Many (一对多):

   • 意义：一对多关系表示一个实体可以与多个其他实体相关联，但是这些实体只能与一个该实体相关联。例如，部门和员工之间的关系。一个部门可以有多个员工，但一个员工只能属于一个部门。
   • 示例：部门和员工之间的关系，一个部门可以有多个员工，但是一个员工只能属于一个部门。

　　这些关系的存在意义在于，它们能够更好地组织和描述现实世界中的数据关联。通过正确地建模这些关系，我们可以更有效地查询、更新和管理数据，并且可以确保数据库的一致性和完整性。

二、优劣势对比（相对于直接使用数据库表结构）：

　　优势：

1. 数据结构更清晰：

   • 使用关系模型可以更准确地反映实际世界中的数据关联，使数据结构更加清晰、直观。这样做能够更好地组织数据，使得数据的逻辑关系更容易理解。

2. 减少数据冗余：

   • 在使用关系模型时，可以避免数据冗余，因为每个实体只需要存储自己的信息，而不需要重复存储相关实体的信息。这样可以节省存储空间，并减少数据更新时的复杂性。

3. 更容易维护：

   • 使用关系模型可以更容易地维护数据的一致性和完整性。由于数据的逻辑结构更清晰，因此对数据进行更新、删除和查询等操作会更加简单和直观。

4. 支持更复杂的查询：

   • 关系模型使得可以执行更复杂的查询操作，例如跨多个实体的联合查询、多层级的查询等。这些查询在直接使用表结构时可能会更加繁琐和复杂。

5. 提高代码可读性和可维护性：

   • 通过使用关系模型，可以编写更具可读性和可维护性的代码，因为代码可以更直观地反映数据之间的关系，降低了开发人员理解和维护代码的难度。

　　尽管使用关系模型可能会增加一些复杂性，但它们通常可以提供更好的数据组织结构和更高的灵活性，从而使得数据库设计更加健壮和可扩展。

　　劣势：

1. 性能影响：

   • 使用关系模型可能会对性能产生一定的影响。因为在执行查询时，可能需要进行关联操作，这可能会导致更复杂的查询语句和更长的查询时间。尤其是在处理大量数据时，这种影响可能会更加明显。

2. 复杂性增加：

   • 关系模型可能会增加数据结构的复杂性，使得数据库设计和维护变得更加困难。特别是在设计涉及多个实体之间复杂关系的数据库时，可能需要更多的关注和精力来管理数据模型。

3. 数据完整性和一致性的挑战：

   • 使用关系模型可能会增加数据完整性和一致性方面的挑战。例如，当删除一个实体时，可能需要考虑到与其关联的其他实体，以确保数据的一致性。这可能需要更多的代码来处理这些情况，增加了开发和维护的复杂性。

4. 不适用于简单场景：

   • 对于一些简单的数据关系，使用关系模型可能会显得过于复杂。在这种情况下，直接使用数据库表结构可能会更加简单和直观，不需要引入额外的复杂性。

5. 学习成本增加：

   • 对于开发人员来说，使用关系模型可能需要额外的学习成本。尤其是对于那些没有使用过ORM（对象关系映射）工具或者不熟悉关系数据库设计的开发人员来说，需要花费更多的时间来理解和掌握这些概念。

尽管关系模型有其劣势，但在许多情况下，它们仍然是一种有效的数据库设计方法，特别是在处理复杂的数据关系和需要灵活查询的情况下。因此，在选择数据库设计方案时，需要综合考虑实际需求、性能要求以及开发团队的技术水平等因素。

三、GORM具体操作

　　重点：

　　　1. 在 GORM 中，Association 是一个用于处理模型之间关联关系的方法。具体来说，Association 方法用于获取与模型关联的其他模型的查询构建器，并提供了一系列方法来操作这些关联模型。

　　　　对于 many-to-many 关系，Association 方法允许你获取和操作关联的中间表的查询构建器。你可以使用 Association 方法来执行以下操作：

1. 1. Append：将一个或多个关联模型添加到中间表中。
   2. Replace：用给定的关联模型替换中间表中的所有关联模型。
   3. Delete：从中间表中删除与给定关联模型相匹配的记录。
   4. Clear：清空中间表中所有关联的记录。

　　　　对于 one-to-many 和 many-to-one 关系，Association 方法类似地允许你获取和操作关联的模型的查询构建器。你可以使用 Association 方法来执行以下操作：

1. 1. Append：将一个或多个关联模型添加到关联的模型中。
   2. Replace：用给定的关联模型替换关联的模型。
   3. Delete：删除关联的模型。

　　　　通过使用 Association 方法，你可以方便地管理模型之间的关联关系，执行添加、替换、删除等操作，而不需要手动编写 SQL 语句。这使得数据操作更加简单和直观。

　　2. Preload 是一个用于预加载关联数据的方法。当你查询一个模型的时候，有时候你需要同时加载关联的数据，以避免 N+1 查询问题，即每次查询主模型都会额外执行一次查询来获取关联模型的数据。

　　　　Preload 方法允许你在查询主模型时预加载关联模型的数据，从而在一次数据库查询中获取主模型及其关联模型的数据，而不是在之后的每次访问关联模型时执行额外的查询。

　　　　例如，假设你有一个 User 模型，每个用户有多个 Post，你想在查询用户时预加载用户的所有帖子数据，你可以使用 Preload 方法：

　　　　这将会在查询用户时预加载用户的所有帖子数据，以避免之后在访问用户的帖子时执行额外的查询。在这个例子中，假设 User 模型有一个名为 Posts 的关联关系，用于关联用户的帖子。

　　　　Preload 方法也可以用于多级关联关系。例如，如果 Post 模型还有一个名为 Comments 的关联关系，你可以这样预加载用户的帖子以及每个帖子的评论数据：

　　　　这将会在查询用户时预加载用户的所有帖子以及每个帖子的评论数据。

　　3. 标签foreignkey 和 association_foreignkey 是用于定义关联关系的两个重要标签，它们有以下区别：

1. 1. foreignkey：

   • • foreignkey 用于指定当前模型在关联关系中的外键字段。
     • 当你在一个模型中定义了一个关联关系时，通常你需要指定当前模型在关联关系中的外键字段，以便 GORM 知道如何在数据库中建立关联。
     • 例如，在一个多对一关系中，外键字段通常存在于“多”方，而 foreignkey 用于指定这个外键字段。

   1. association_foreignkey：

   • • association_foreignkey 用于指定当前模型关联的另一个模型在关联关系中的外键字段。
     • 当你在　　一个模型中定义了一个关联关系时，有时候你可能需要指定关联的另一个模型在关联关系中的外键字段，以便 GORM 知道如何在数据库中建立关联。
     • 例如，　　在一个多对一关系中，另一个模型通常为“一”方，而 association_foreignkey 用于指定这个另一个模型在关联关系中的外键字段。

　　　　　　总之，foreignkey 用于指定当前模型在关联关系中的外键字段，而 association_foreignkey 用于指定当前模型关联的另一个模型在关联关系中的外键字段。这两个标签的作用是为了告诉 GORM 如何在数据库中建立关联。

　　many2many

 1 package main
 2 
 3 import "gorm.io/gorm"
 4 
 5 type User struct {
 6     ID    uint `gorm:"primaryKey"`
 7     Name  string
 8     Roles []Role `gorm:"many2many:user_roles;association_foreignkey:RoleID;foreignkey:UserID;"`
 9 }
10 
11 type Role struct {
12     ID    uint `gorm:"primaryKey"`
13     Name  string
14     Users []User `gorm:"many2many:user_roles;association_foreignkey:UserID;foreignkey:RoleID;"`
15 }
16 
17 type UserRole struct {
18     UserID uint
19     RoleID uint
20 }
21 
22 // 设置表名称
23 func (table *User) TableName() string {
24     return "sys_user"
25 }
26 
27 // 设置表名称
28 func (table *Role) TableName() string {
29     return "sys_role"
30 }
31 
32 // 设置表名称
33 func (table *UserRole) TableName() string {
34     return "user_roles"
35 }
36 
37 func SaveUserWithRoles(user *User, db *gorm.DB) error {
38     // 如果用户ID为0，则表示要创建新用户
39     if user.ID == 0 {
40         if err := db.Create(user).Error; err != nil {
41             return err
42         }
43     } else { // 否则更新用户记录
44         if err := db.Save(user).Error; err != nil {
45             return err
46         }
47     }
48 
49     // 处理用户的角色
50     var roleIDs []uint
51     for _, role := range user.Roles {
52         // 如果角色ID为0，则表示要创建新角色
53         if role.ID == 0 {
54             if err := db.Create(&role).Error; err != nil {
55                 return err
56             }
57         } else { // 否则更新角色记录
58             if err := db.Save(&role).Error; err != nil {
59                 return err
60             }
61         }
62         roleIDs = append(roleIDs, role.ID)
63     }
64 
65     // 替换用户的角色为最新的角色列表
66     if err := db.Model(user).Association("Roles").Replace(user.Roles); err != nil {
67         return err
68     }
69 
70     return nil
71 }

 　　many2one one2many

 1 package main
 2 
 3 // User 和 Address，一个用户可以有多个地址，但是每个地址只属于一个用户。同时，我们还有一个 Location 模型，地址可以关联到一个地点。在这种情况下，我们可以使用 foreignKey 和 association_foreignkey 来指定外键。
 4 // 在这个例子中，我们在 Address 模型中同时使用了 foreignKey 和 association_foreignkey。foreignKey:UserID 指定了关联到 User 模型的外键，而 association_foreignkey:LocationID 指定了关联到 Location 模型的外键。
 5 type User struct {
 6     ID       uint       `gorm:"primaryKey"`
 7     Name     string
 8     Addresses []Address `gorm:"foreignKey:UserID"`
 9 }
10 
11 type Address struct {
12     ID         uint       `gorm:"primaryKey"`
13     Street     string
14     UserID     uint       // 外键，用于关联到 User 模型。该字段类型必须和User中的ID字段类型一致
15     LocationID uint       // 地点ID，外键，用于关联到 Location 模型
16     Location   Location   `gorm:"foreignKey:LocationID"`
17 }
18 
19 type Location struct {
20     ID   uint   `gorm:"primaryKey"`
21     City string
22 }
23 
24 
25 // 创建一个新用户
26 user := User{Name: "Alice"}
27 
28 // 创建用户的地址
29 address1 := Address{Street: "123 Main St", UserID: user.ID}
30 address2 := Address{Street: "456 Elm St", UserID: user.ID}
31 
32 // 创建地址的地点
33 location := Location{City: "New York"}
34 
35 // 保存地点到数据库
36 db.Create(&location)
37 
38 // 设置地址的地点ID
39 address1.LocationID = location.ID
40 address2.LocationID = location.ID
41 
42 // 保存用户的地址到数据库
43 db.Create(&address1)
44 db.Create(&address2)
45 
46 // 保存用户到数据库
47 if err := db.Create(&user).Error; err != nil {
48     // 处理错误
49 }