Question

我正在使用mongoose和combo mongoDb / nodejs。我想 findOne（）一个有某些条件的文档。

我的架构：

var prognosticSchema = new Schema({
    userRef : { type : Schema.Types.ObjectId, ref : 'users'},
    matchRef : { type : Schema.Types.ObjectId, ref : 'match'},
    ...
});

模型架构＆＃39;用户＆＃39; 包含字符串＆＃39;电子邮件＆＃39; 和型号＆＃39;匹配＆＃39 ; 包含数字＆＃39; id_match＆＃39; ，如下所示：

var userSchema = new Schema({
    email: String,
    ...
});

然后

var matchSchema = new Schema({
    id_match: {type: Number, min: 1, max: 51},
    ...
});

我的目标是 findOne（）一个包含 id_match = id_match 和电子邮件 =的文档 req.headers [＆＃39; X-KEY＆＃39]。

我试过了：

var prognoSchema = require('../db_schema/prognostic'); // require prognostics
require('../db_schema/match'); // require match to be able to populate

var prognoQuery = prognoSchema.find()
    .populate({path: 'userRef', // populate userRef
    match : {
        'email' : req.headers['x-key'] // populate where email match with email in headers of request (I'm using Express as node module)
    },
    select : 'email pseudo'
    });

    prognoQuery.findOne() // search for only one doc
        .populate({path: 'matchRef', // populate match
        match: {
            'id_match': id_match // populate match where id_match is correct
        }})
        .exec(function(err, data) {
             ... // Return of value as response ...
        }

当我运行此代码并尝试获取正确的文档时，知道其他 prognosticSchema 与其他用户和匹配我的数据库，我的 userRef 为空，并在我的数据文档中更正 matchRef 。

在我的数据库中，还有其他用户和其他 id_match ，但我希望在 findOne（）中获取正确的文档。我的架构中有两个objectId。

有没有办法 findOne（）一个匹配两个不同的填充的文档，并在 findOne（）中获取他的文档？

Answer 1

你可以包括＆＃34;两者＆＃34;同一查询中的populate个表达式，但当然因为您实际上想要匹配＆＃34;关于＆＃34;引用＆＃34;中包含的属性集合这意味着从＆＃34;父母＆＃34;需要看看所有的父母和＃34;首先是为了填充数据：

prognoSchema.find()
  .populate([
    { 
      "path": "userRef",
      "match": { "email": req.headers['x-key'] }
    },
    { 
      "path": "matchRef",
      "match": { "id_match": id_match }
    }
  ]).exec(function(err,data) {
      /* 
          data contains the whole collection since there was no
          condition there. But populated references that did not
          match are now null. So .filter() them:
      */
      data = data.filter(function(doc) {
          return ( doc.userRef != null && doc.matchRef != null );
      });

      // data now contains only those item(s) that matched
  })

这不是理想的，但它是如何使用＆＃34;引用＆＃34;数据有效。

更好的方法是搜索其他馆藏＆＃34;个别＆＃34;对于单个匹配，然后将找到的_id值提供给＆＃34;父级＆＃34;采集。来自async.parallel的一点帮助，以便在使用匹配值执行父级之前等待其他查询的结果。可以通过各种方式完成，但这看起来相当干净：

async.parallel(
    {
        "userRef": function(callback) {
            User.findOne({ "email": req.headers['x-key'] },callback);
        },
        "id_match": function(callback) {
            Match.findOne({ "id_match": id_match },callback);
        }
    },
    function(err,result) {
        prognoSchema.findOne({
            "userRef": result.userRef._id,
            "matchRef": result.id_match._id
        }).populate([
          { "path": "userRef", "match": { "email": req.headers['x-key'] } },
          { "path": "matchRef", "match": { "id_match": id_match } }
        ]).exec(function(err,progno) {
            // Matched and populated data only
        })
    }
)

作为替代方案，在3.2及更高版本的现代MongoDB版本中，您可以使用$lookup聚合运算符代替：

prognoSchema.aggregate(
    [
        // $lookup the userRef data
        { "$lookup": {
            "from": "users",
            "localField": "userRef",
            "foreignField": "_id",
            "as": "userRef"
        }},
        // target is an array always so $unwind
        { "$unwind": "$userRef" },
        // Then filter out anything that does not match
        { "$match": {
            "userRef.email": req.headers['x-key']
        }},
        // $lookup the matchRef data
        { "$lookup": {
            "from": "matches",
            "localField": "matchRef",
            "foreignField": "_id",
            "as": "matchRef"
        }},
        // target is an array always so $unwind
        { "$unwind": "$matchRef" },
        // Then filter out anything that does not match
        { "$match": {
            "matchRef.id_match": id_match
        }}
    ],
    function(err,prognos) {

    }
)

但同样丑陋，因为＆＃34;来源＆＃34;仍在选择所有内容，并且您只是在每次$lookup操作后逐渐过滤掉结果。

这里的基本前提是＆＃34; MongoDB没有＆＃39; 执行联接＆＃34; ，{{1} } a＆＃34; JOIN＆＃34;，但只是对相关集合的其他查询。因为这是＆＃34;不是＆＃34; a＆＃34;加入＆＃34;没有办法过滤掉父母＆＃34;直到检索到实际的相关数据。即使它已在＆＃34;服务器＆＃34;上完成通过$lookup而不是＆＃34;客户＆＃34;通过.populate()

所以如果你＆＃34;必须＆＃34;通过这种方式查询，通常可以更好地查询其他集合的结果＆＃34; first＆＃34;然后匹配＆＃34;父母＆＃34;基于匹配的.populate()属性值作为参考。

但另一种情况是你＆＃34;应该＆＃34;考虑＆＃34;嵌入＆＃34;相反，数据是你打算＆＃34;查询＆＃34;在那些属性上。仅当该数据位于＆＃34;单个集合＆＃34; MongoDB可以通过单个查询和高性能操作来查询和匹配这些条件。

有没有办法找到一个匹配两个不同填充的文档，并在findOne（）中获取他的文档？

1 个答案: