Golang中MongoDB聚合文档返回与字段解码问题求助

问题 #

我在通用博客文章模型中尝试聚合category字段（该字段实际为ObjectId，但存储为string更便于操作），模型定义如下：

type Post struct {
    ID          primitive.ObjectID       `json:"_id" bson:"_id,omitempty"`
    Title       *string                  `json:"title" bson:"title"`
    Slug        *string                  `json:"slug" bson:"slug"`
    Content     []map[string]interface{} `json:"content" bson:"content,omitempty"`
    Category    *string                  `json:"category" bson:"category,omitempty"`
}

我使用了包含$match、$lookup、$unwind的聚合管道：

match := bson.D{
    {
        "$match", bson.D{
            {
                "slug", slug,
            },
        },
    },
}

lookup := bson.D{
    {
        "$lookup", bson.D{
            {
                "from", categories.Model_name,
            },
            {
                "localField", "category",
            },
            {
                "foreignField", "_id",
            },
            {
                "as", "category",
            },
        },
    },
}

unwind := bson.D{
    {
        "$unwind", bson.D{
            {
                "path", "$category",
            },
        },
    },
}

cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{match, lookup, unwind})

var results []Post
if err = cursor.All(context.TODO(), &results); err != nil {
    panic(err)
}

但出现错误：panic: error decoding key category: cannot decode array into a string type。同时保留$unwind阶段时查询结果为空，移除该阶段则无法完成解码。我的需求是获取单条文档并聚合category字段，不想创建多个结构体，请问该如何解决？是否有更高效的实现方式？

解决方案 #

核心问题分析 #

1. 解码失败原因：$lookup执行后会将匹配到的分类文档存入数组（即使仅一条匹配），但你的Post结构体中Category是*string类型，类型不匹配导致解码错误。
2. $unwind后结果为空：因为你的category存为string类型，而分类集合的_id是primitive.ObjectID，类型不匹配导致$lookup未找到匹配数据，$unwind直接过滤了该文档。

不新增结构体的解决办法 #

方法一：调整聚合管道适配类型

通过添加类型转换阶段、保留空匹配文档，让聚合结果能适配原结构体（需小幅修改字段类型）：

// 新增：将string类型的category转换为ObjectId，用于匹配分类集合的_id
addFields := bson.D{
    {
        "$addFields", bson.D{
            {
                "categoryId", bson.D{{"$toObjectId", "$category"}},
            },
        },
    },
}

lookup := bson.D{
    {
        "$lookup", bson.D{
            {"from", categories.Model_name},
            {"localField", "categoryId"},
            {"foreignField", "_id"},
            {"as", "category"},
        },
    },
}

// 修改unwind：保留没有匹配到分类的文档
unwind := bson.D{
    {
        "$unwind", bson.D{
            {"path", "$category"},
            {"preserveNullAndEmptyArrays", true},
        },
    },
}

// 可选：通过$project处理匹配结果，没匹配到则保留原string值
project := bson.D{
    {
        "$project", bson.D{
            {"_id", 1},
            {"title", 1},
            {"slug", 1},
            {"content", 1},
            {"category", bson.D{{"$cond", bson.A{
                bson.D{{"$ifNull", bson.A{"$category", false}}},
                "$category",
                "$category",
            }}}},
        },
    },
}

// 聚合管道顺序：match -> addFields -> lookup -> unwind -> project
cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{match, addFields, lookup, unwind, project})

然后修改Post结构体的Category字段为interface{}，兼容string和分类文档两种类型：

type Post struct {
    ID          primitive.ObjectID       `json:"_id" bson:"_id,omitempty"`
    Title       *string                  `json:"title" bson:"title"`
    Slug        *string                  `json:"slug" bson:"slug"`
    Content     []map[string]interface{} `json:"content" bson:"content,omitempty"`
    Category    interface{}              `json:"category" bson:"category,omitempty"`
}

方法二：两次简单查询（更高效）

因为只需要单条文档，聚合管道的开销比两次简单查询大，直接分步查询后手动关联：

// 1. 查询目标文章
var post Post
err := collection.FindOne(context.TODO(), bson.D{{"slug", slug}}).Decode(&post)
if err != nil {
    panic(err)
}

// 2. 若文章有category值，查询对应分类
if post.Category != nil && *post.Category != "" {
    catId, err := primitive.ObjectIDFromHex(*post.Category)
    if err != nil {
        panic(err)
    }
    var category map[string]interface{}
    err = categoriesCollection.FindOne(context.TODO(), bson.D{{"_id", catId}}).Decode(&category)
    if err == nil {
        // 需将Post的Category字段改为interface{}才能接收分类文档
        post.Category = category
    }
}

长期优化建议 #

如果频繁需要关联查询，建议直接将Post结构体的Category字段定义为primitive.ObjectID类型，避免类型转换的麻烦，同时让索引匹配更高效。

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