How to create through association in Golang GORM?

Creating associations with the GORM framework in Go is simple and intuitive, primarily involving defining models and using appropriate tags to specify association types (such as one-to-one, one-to-many, and many-to-many). Here, I will provide a detailed explanation of how to define these associations, along with some practical code examples.

One-to-One Association

Assume we have two models: User and Profile. Each user has a unique profile. We can define the models as follows:

go
type User struct {
    gorm.Model
    Name    string
    Profile Profile // one-to-one association
}


type Profile struct {
    gorm.Model
    UserID uint
    Bio    string
}

In this case, the User model includes a Profile field, indicating that each User can have one Profile. In the Profile model, we establish the reverse relationship using UserID.

Creating Records

go
user := User{Name: "John Doe", Profile: Profile{Bio: "Born in the cloud, grown in code."}}
result := db.Create(&user) // Using GORM's Create method
if result.Error != nil {
    log.Fatalf("Failed to create user: %v", result.Error)
}

One-to-Many Association

Consider a scenario where a user can have multiple email addresses. We can define the User and Email models as follows:

go
type User struct {
    gorm.Model
    Name   string
    Emails []Email // one-to-many association
}


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

In this example, the User has multiple Email entries, established by the UserID in the Email model.

Creating Records

go
user := User{
    Name: "John Doe",
    Emails: []Email{
        {Email: "john@example.com"},
        {Email: "john.doe@example.com"},
    },
}
result := db.Create(&user)
if result.Error != nil {
    log.Fatalf("Failed to create user: %v", result.Error)
}

Many-to-Many Association

In a many-to-many scenario, such as the relationship between users and roles, each user can have multiple roles, and each role can include multiple users:

go
type User struct {
    gorm.Model
    Name   string
    Roles  []Role `gorm:"many2many:user_roles;"`
}


type Role struct {
    gorm.Model
    Name  string
    Users []User `gorm:"many2many:user_roles;"`
}

We create the many-to-many association by adding the gorm:"many2many:user_roles;" tag to both models, where user_roles is the name of the intermediate table connecting the two models.

Creating Records

go
user := User{
    Name: "John Doe",
    Roles: []Role{
        {Name: "Administrator"},
        {Name: "Member"},
    },
}
result := db.Create(&user)
if result.Error != nil {
    log.Fatalf("Failed to create user: %v", result.Error)
}

The above outlines the basic methods for creating associations in GORM. In actual development, choose the appropriate association type based on specific requirements, and implement complex data relationships and operations through proper model definitions and GORM methods.