93

我有Category模型：

Category:
    ...
    articles: [{type:ObjectId, ref:'Article'}]

文章模型包含参考Account model。

Article:
    ...
    account: {type:ObjectId, ref:'Account'}

因此，填充articles类别模型将是：

{ //category
    articles: //this field is populated
     [ { account: 52386c14fbb3e9ef28000001, // I want this field to be populated
         date: Fri Sep 20 2013 00:00:00 GMT+0400 (MSK),
         title: 'Article 1' } ],
    title: 'Category 1' }

问题是：如何填充填充字段（[文章]）的子字段（帐户）？这是我现在的做法：

globals.models.Category
    .find
        issue : req.params.id
        null
        sort:
            order: 1
    .populate("articles") # this populates only article field, article.account is not populated
    .exec (err, categories) ->
        console.log categories

我知道这里讨论过：猫鼬：填充填充字段，但没有找到真正的解决方案

4

10 回答 10

194

首先，将 mongoose 3 更新为 4，然后使用最简单的方法在 mongoose 中进行深度填充，如下所示：

假设您的博客架构具有 userId 作为 ref Id，然后在 User 中您有一些评论作为架构 Review 的 ref Id。所以基本上，你有三个模式：1.博客 2.用户 3.评论

而且，你必须从博客中查询，哪个用户拥有这个博客和用户评论。因此，您可以将结果查询为：

BlogModel
  .find({})
  .populate({
    path : 'userId',
    populate : {
      path : 'reviewId'
    }
  })
  .exec(function (err, res) {

  })
于 2016-10-05T15:52:02.883 回答
41

跨多个级别填充

假设您有一个跟踪用户朋友的用户模式。

var userSchema = new Schema({
  name: String,
  friends: [{ type: ObjectId, ref: 'User' }]
});

填充可让您获取用户的朋友列表，但如果您还想要用户的朋友的朋友怎么办？指定填充选项来告诉猫鼬填充所有用户朋友的朋友数组：

User.findOne({ name: 'Val' }).populate({
    path: 'friends',
    // Get friends of friends - populate the 'friends' array for every friend
    populate: { path: 'friends' }
});

参考： http: //mongoosejs.com/docs/populate.html#deep-populate

于 2017-01-12T18:35:08.543 回答
25

Mongoose 现在有了一种新Model.populate的深度关联方法：

https://github.com/Automattic/mongoose/issues/1377#issuecomment-15911192

于 2014-03-07T14:58:42.950 回答
21

可能有点太晚了，但我写了一个Mongoose 插件来在任意嵌套级别执行深度填充。注册此插件后，您只需一行即可填充类别的文章和帐户：

Category.deepPopulate(categories, 'articles.account', cb)

您还可以指定填充选项来控制每个填充路径的limit, ... 等内容。select查看插件文档以获取更多信息。

于 2014-12-10T19:35:08.373 回答
10

在 3.6 中完成此操作的最简单方法是使用Model.populate.

User.findById(user.id).select('-salt -hashedPassword').populate('favorites.things').exec(function(err, user){
    if ( err ) return res.json(400, err);

    Thing.populate(user.favorites.things, {
        path: 'creator'
        , select: '-salt -hashedPassword'
    }, function(err, things){
        if ( err ) return res.json(400, err);

        user.favorites.things = things;

        res.send(user.favorites);
    });
});
于 2014-06-13T05:30:28.883 回答
8

或者您可以将 Object 传递给 populate 方法，如下所示：

const myFilterObj = {};
const populateObj = {
                path: "parentFileds",
                populate: {
                    path: "childFileds",
                    select: "childFiledsToSelect"
                },
                select: "parentFiledsToSelect"
               };
Model.find(myFilterObj)
     .populate(populateObj).exec((err, data) => console.log(data) );
于 2020-01-16T10:18:36.280 回答
5

这个概念是深人口。这里的Calendar,Subscription,User,Apartment是mongoose ODM模型的不同层次

Calendar.find({}).populate({
      path: 'subscription_id',model: 'Subscription',
         populate: {path: 'user_id',model: 'User',
           populate: {path: 'apartment_id',model: 'Apartment',
              populate: {path: 'caterer_nonveg_id',
                          model: 'Caterer'}}}}).exec(function(err,data){ 
                          if(!err){
                             console.log('data all',data)
                           }
                           else{
                             console.log('err err err',err)
                            }
                   });
于 2018-12-28T11:48:04.573 回答
3

很抱歉打破你的泡沫，但没有直接支持的解决方案。至于Github issue #601，看起来很严峻。根据3.6 发行说明，开发人员似乎承认该问题对手动递归/深度填充感到满意。

所以从发行说明来看，推荐的方法是在回调中嵌套填充的调用，所以在你的exec()函数中，categories.populate在发送响应之前使用它来进一步填充。

于 2013-10-24T21:56:09.257 回答
2 
globals.models.Category.find()
  .where('issue', req.params.id)
  .sort('order')
  .populate('articles')
  .exec(function(err, categories) {

    globals.models.Account.populate(categories, 'articles.account', function(err, deepResults){

      // deepResult is populated with all three relations
      console.log(deepResults[0].articles[0].account);

    });
});

以下示例受到@codephobia 问题的启发，并填充了许多关系的两个级别。首先获取 a user，填充其相关orders 数组并包含每个orderDetail。

user.model.findOne()
  .where('email', '***@****.com')
  .populate('orders')
  .exec(function(err, user) {

    orderDetail.model.populate(user, 'orders.orderDetails', function(err, results){

      // results -> user.orders[].orderDetails[] 
    });
});

这可以正常工作，3.8.8但应该可以在3.6.x.

于 2014-12-06T17:43:10.507 回答
0

如果你想在 populate 中选择多填充，你应该尝试这种方式：

我有预订模式：

let Booking = new Schema({
  ...,  // others field of collection
  experience: { type: Schema.Types.ObjectId, ref: 'Experience' },
  ...},{
    collection: 'booking'
  });

和体验模式：

let Experience = new Schema({
  ...,
  experienceType: {type: Schema.Types.ObjectId, ref: 'ExperienceType'},
  location: {type: Schema.Types.ObjectId, ref: 'Location'},
  ...} // others field of collection
  ,{
    collection: 'experience'
  });

找到Booking时获取ExperienceType 和 Location of Experience：

Booking.findOne({_id: req.params.id})
  .populate({path: 'experience',
    populate: [{path: 'experienceType', select: 'name'}, {path: 'location', select: 'name'}],
  })
  .exec((err, booking) => {
    if(err){
      console.log(err);
    }
    else {
      res.json(booking);
    }
  });
于 2019-12-08T15:43:38.073 回答