How to Handle N+1 Query Problem in Go GraphQL

The N+1 query problem in Go GraphQL is solved by batching data loaders to execute a single query per type instead of one per field. Implement a DataLoader that collects all requested IDs during the resolve phase and executes one aggregated database query.

type UserLoader struct {
    batchFunc func(ctx context.Context, keys []string) ([]*User, []error)
    cache     map[string]*User
}

func (l *UserLoader) Load(ctx context.Context, id string) (*User, error) {
    if u, ok := l.cache[id]; ok {
        return u, nil
    }
    // Trigger batch if not cached (simplified logic)
    users, errs := l.batchFunc(ctx, []string{id})
    if len(users) > 0 {
        l.cache[id] = users[0]
        return users[0], nil
    }
    return nil, errs[0]
}

func (r *QueryResolver) Users(ctx context.Context) ([]*User, error) {
    // Fetch all users in one query
    allUsers, err := db.FindAllUsers(ctx)
    if err != nil {
        return nil, err
    }
    // Populate loader cache
    loader := &UserLoader{cache: make(map[string]*User)}
    for _, u := range allUsers {
        loader.cache[u.ID] = u
    }
    return allUsers, nil
}

The N+1 problem happens when your code makes one database call to get a list, then makes another call for every single item in that list. It is like a librarian fetching a list of book titles, then walking to the shelf to grab each book individually instead of grabbing them all at once. Batching fixes this by collecting all the requests and fetching everything in a single trip.