How to multiple table joins in GORM

Performing multi-table joins in GORM involves several key steps. I will illustrate this process with an example.

Assume we have two models: User and Profile, where the User model represents users and the Profile model represents user details. Their relationship is one-to-one.

First, we need to define the models and set up appropriate association fields within them. Here is how to define these models:

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

type Profile struct {
    gorm.Model
    UserID  uint // foreign key
    Address string
    Age     int
}

In GORM, we can use the Preload, Joins, or Related methods to perform join operations. Here are some examples of using these methods:

Using Preload

Preload is a convenient method for automatically loading associated data. It executes additional queries to populate the associated data.

go
var users []User
db.Preload("Profile").Find(&users)

This will load the user list and the associated profiles for each user.

Using Joins

If you need more complex join operations, such as selecting specific fields or conditional joins, you can use the Joins method.

go
var result []struct {
    UserName string
    Address  string
}

db.Model(&User{}).
    Select("users.name as user_name, profiles.address as address").
    Joins("left join profiles on profiles.user_id = users.id").
    Scan(&result)

In this example, we create a join query to retrieve the username and address, using a custom struct to store the results.

Using Related

The Related method can be used to manually load associated data. This is used when the main record has already been loaded.

go
var user User
db.First(&user, 1) // Assume we load the user with ID 1

var profile Profile
db.Model(&user).Related(&profile)

Here, we first load a user and then load the associated profile for that user.

Summary

In GORM, multi-table joins can be implemented in various ways, and the choice of method depends on your specific requirements. The Preload method is suitable for simple automatic association loading, Joins provides higher flexibility, and Related is useful when you already have the main record loaded. In actual development, choosing the appropriate method can help you handle database operations more efficiently.