如何从PostgreSQL查询数据并映射到含嵌套结构体切片的Go结构体？

针对你用PostgreSQL+pgx+scany实现Post和Comment一对多关系的嵌套映射需求，以下是几个无需N+1查询的优秀方案：

方案1：手动遍历结果行，合并重复Post与关联Comments #

这种方式无需额外依赖，完全手动处理查询返回的行，合并重复的Post记录并填充Comments切片：

func (pr *PostRepository) GetAll() ([]models.Post, error) {
    query := `SELECT p.id AS post_id, p.*, c.id AS comment_id, c.post_id AS comment_post_id, c.* 
              FROM posts p
              LEFT OUTER JOIN comments c ON c.post_id = p.id;`

    rows, err := pr.dbPool.Query(context.Background(), query)
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    postMap := make(map[int64]*models.Post)
    var posts []models.Post

    for rows.Next() {
        var post models.Post
        var comment models.Comment
        // 给重复字段加别名，避免扫描时字段冲突
        err := pgxscan.ScanRow(&post, rows, pgxscan.SelectFields("post_id", "p.*"))
        if err != nil {
            return nil, err
        }
        // 扫描Comment字段，过滤无Comment的情况
        if rows.Err() == nil {
            err = pgxscan.ScanRow(&comment, rows, pgxscan.SelectFields("comment_id", "c.*"))
            if err != nil && err != pgx.ErrNoRows {
                return nil, err
            }
        }

        // 合并Post到map中去重，追加对应Comment
        if existingPost, ok := postMap[post.Id]; ok {
            if comment.Id != 0 {
                existingPost.Comments = append(existingPost.Comments, comment)
            }
        } else {
            if comment.Id != 0 {
                post.Comments = []models.Comment{comment}
            } else {
                post.Comments = []models.Comment{}
            }
            postMap[post.Id] = &post
            posts = append(posts, post)
        }
    }

    if err := rows.Err(); err != nil {
        return nil, err
    }

    return posts, nil
}

关键点： #

• 查询时给重复字段（如id）加别名，避免扫描时字段冲突
• 用map存储已处理的Post，通过Post ID去重，将同一Post的Comment追加到切片中
• 处理LEFT JOIN返回的NULL Comment情况，避免无效数据加入切片

方案2：利用PostgreSQL JSON聚合函数，一次查询聚合Comments #

通过PostgreSQL的json_agg函数将每个Post的Comments聚合为JSON数组，再在Go中解析为[]Comment字段：

import "encoding/json"

func (pr *PostRepository) GetAll() ([]models.Post, error) {
    query := `SELECT 
                p.*,
                COALESCE(json_agg(c) FILTER (WHERE c.id IS NOT NULL), '[]') AS comments
              FROM posts p
              LEFT OUTER JOIN comments c ON c.post_id = p.id
              GROUP BY p.id;`

    // 定义临时结构体接收JSON格式的Comments
    type postWithJSONComments struct {
        models.Post
        CommentsJSON []byte `db:"comments"`
    }

    var tempPosts []postWithJSONComments
    err := pgxscan.Select(context.Background(), pr.dbPool, &tempPosts, query)
    if err != nil {
        return nil, err
    }

    // 将JSON数组解析为[]Comment
    var posts []models.Post
    for i := range tempPosts {
        posts = append(posts, tempPosts[i].Post)
        err := json.Unmarshal(tempPosts[i].CommentsJSON, &posts[i].Comments)
        if err != nil {
            return nil, err
        }
    }

    return posts, nil
}

关键点： #

• 使用json_agg(c) FILTER (WHERE c.id IS NOT NULL)聚合有效Comment，并用COALESCE确保无Comment时返回空数组
• 借助encoding/json将数据库返回的JSON数组解析为Go切片
• 数据库层面完成聚合，减少Go端的行处理逻辑

方案3：扩展scany的扫描逻辑（自定义结构体扫描器） #

如果想复用scany的扫描能力，可以实现pgx.Scanner接口来处理嵌套切片的扫描：

import "fmt"

// 给Post结构体实现pgx.Scanner接口
func (p *Post) Scan(src interface{}) error {
    row, ok := src.(pgx.Row)
    if !ok {
        return fmt.Errorf("unsupported source type")
    }

    // 扫描Post基础字段
    err := pgxscan.ScanRow(p, row)
    if err != nil {
        return err
    }

    // 扫描Comment字段并追加到切片
    var comment models.Comment
    err = pgxscan.ScanRow(&comment, row)
    if err == nil && comment.Id != 0 {
        p.Comments = append(p.Comments, comment)
    } else if err != pgx.ErrNoRows {
        return err
    }

    return nil
}

注意： #

这种方式需要深入理解scany和pgx的扫描机制，适合需要高度自定义扫描逻辑的场景，日常场景推荐方案1或2。

内容的提问来源于stack exchange，提问作者Sovak