node.js - Mongoose 用排序和限制填充虚拟

coder 2023-10-29 原文

我正在尝试编写一个 mongoose 查询来检索一组 Assets 以及这些 Assets 的最新交易。交易与 Assets 位于不同的集合中。

为此，我首先在 Assets 模型中创建了一个虚拟数组，以将 Assets 与交易联系起来。

schema.virtual('transactions', {
    ref: 'transaction',
    localField: '_id',
    foreignField: '_asset',
    justOne: false
})

然后我在 node.js express Controller 中使用 .populate 进行查询(注意硬编码的“limit: 1”在某个时候会变成 N):

exports.getList = function (req, res) {
    Model
        .find({}, { __v: 0 })
        .populate({
            path: 'transactions',
            options: { sort: { 'created_at': -1}, limit: 1},
        })
        .lean()
        .exec(function (err, model) {
            if (err)
                res.send(err);
            res.json(model);
        });
  }

我的测试系统中有 3 个 Assets ，每个 Assets 都有一堆交易，它返回前两个 Assets 的旧交易，而第三个 Assets 没有任何交易。

当我删除“limit:1”并返回所有交易时，它会正确排序并返回所有三个 Assets 的交易。

我相信我遇到了这个错误:

https://github.com/Automattic/mongoose/issues/4321

关于优雅的解决方法的任何想法？
返回所有交易将不是一个可行的长期解决方案。

最佳答案

这确实是一个棘手的问题。这里的基础知识是 .populate() 并且当然不是“填充虚拟”，其设计目的不是像您在这里期望的那样工作。

问题说明

本质上 .populate() 本质上是向 MongoDB 发出的另一个查询以检索相关数据。为此，它基本上使用 $in 发出一个查询，其中包含要匹配的目标的所有“相关字段”值。

"issue 4321" 的核心是，使用诸如 "sort" 和 "limit" 之类的选项，需要提供此类 $in 参数的实际查询实际上是一个 .aggregate() 语句，该语句能够“获得为每个分组的最后 n 结果 key ”。这实际上并不是 mongoose 目前向 MongoDB 发出的问题，目前通过可用操作对 n 项进行分组也不太实用。

您可以手动使用 .aggregate() 来解决这个问题，如所提供列表的末尾所示，但当然仅在少数情况下实际上是可行的。

  // Get latest transactions for each master
  Transaction.aggregate([
    { '$match': {
      '_asset': {
        '$in': masters.map(m => m._id)
      }
    }},
    { '$sort': { '_asset': 1, 'createdAt': -1 } },
    { '$group': {
      '_id': '$_asset',
      'amount': { '$first': '$amount' },
      'createdAt': { '$first': '$createdAt' },
      'updatedAt': { '$first': '$updatedAt' },
      'did': { '$first': '$_id' }
    }},
    { '$project': {
      '_id': '$did',
      '_asset': '$_id',
      'amount': 1,
      'createdAt': 1,
      'updatedAt': 1
    }}
  ])

它不是很好，也不是真正高效的解决方案，但比其他类似的替代方案要好。我相信还有更好的方法。

更好的解决方案

对于您这里的情况，我怀疑有许多类似的情况，您不希望在父文档中包含“完整”交易列表，即使由于生成的数组的潜在大小而作为引用。这种“反模式”通常是“虚拟填充”和实际上 $lookup 旨在避免的。

但是，在您“获取最新交易”的特定用例中，这些都不是可行的解决方案。因为两者本质上都需要查看“所有”事务，然后只从它们检索 n 结果。

因此，此处的“最新”或实际上是“最近”的案例实际上会退回到“有限数量”的“嵌入”(至少是引用)以提供可行的解决方案。所以建议就是这样做，并在父级本身中保留一个 "recent" 交易列表。这为您提供了包含的场景中的文档，如下所示:

{
        "_id" : ObjectId("5959e34adf833e1451a32661"),
        "__v" : 0,
        "name" : "One",
        "recent" : [
                ObjectId("5959e34bdf833e1451a32676"),
                ObjectId("5959e34bdf833e1451a32674"),
                ObjectId("5959e34bdf833e1451a32672"),
                ObjectId("5959e34bdf833e1451a32670"),
                ObjectId("5959e34bdf833e1451a3266e")
        ]
}

请注意，这些不是“所有”相关交易，而只是“最近”交易。关键是只保留一个适合目的的“小”列表。

通过这种方式，您可以直接查询“父项”，然后从包含 $slice 项的数组中取出 "recent" 。在 list 中，我这样做:

Master.find().select({ 'recent': { '$slice': 1 } })

这将返回数组中的“最新”条目，而无需向服务器进行任何其他查询。在这种情况下，它是“最新的”，因为我们在写入 "transactions" 集合的同时将项目“添加到”该数组，该集合包含所有内容:

Transaction.create({ _asset: master._id, amount: data.amount })
  .then(transaction =>
    Master.update(
      { _id: transaction._asset },
      { "$push": {
        "recent": {
          "$each": [transaction._id],
          "$position": 0,
          "$slice": 5
        }
      }}
    )

关键元素是父中数组的 $push ，它在数组的开头用 $position 修改为“preprend”，因此“第一”项始终是要添加的与父相关的“最新”事务。

然后这里使用 $slice 修饰符来将 "recent" 数组保持在 n 项的限制范围内。因此，当添加新项目时，“最旧”项目将被“从列表中删除”。

这里还有一个实际目的，就是在分页场景中列出“master”和“transactions”时，第一个请求可以直接使用 "recent" 数组。然后对新“页面”的额外请求，可以简单地通过 "recent" 过滤掉包含在 $nin 数组中的项目，并使用常规的 .skip() 和 .limit() 或替代“范围”分页实践来检索结果的每个“页面”。

要完整演示所有概念，请参阅下面的列表和所有生成的结果。

示范列表:

const async = require('async'),
      mongoose = require('mongoose'),
      Schema = mongoose.Schema;

mongoose.set('debug',true);
mongoose.Promise = global.Promise;

mongoose.connect('mongodb://localhost/prepend');

const transactionSchema = new Schema({
  _asset: { type: Schema.Types.ObjectId, ref: 'Master' },
  amount: Number
},{
  timestamps: {
    createdAt: 'createdAt'
  }
});


const Transaction = mongoose.model('Transaction', transactionSchema);

const masterSchema = new Schema({
  name: String,
  recent: [{ type: Schema.Types.ObjectId, ref: 'Transaction' }]
});

masterSchema.virtual('transactions', {
  ref: 'Transaction',
  localField: '_id',
  foreignField: '_asset',
  justOne: false
});


const Master = mongoose.model('Master', masterSchema);

function log(data) {
  console.log(JSON.stringify(data, undefined, 2))
}

async.series(
  [
    // Clean data
    (callback) =>
      async.each(mongoose.models,(model,callback) =>
        model.remove({},callback),callback),

    // Create Masters
    (callback) =>
      Master.insertMany(['One','Two'].map( name => ({ name })),callback),

    // Add 10 transactions to each master
    (callback) =>
      async.each(['One','Two'],(name,callback) =>
        async.eachSeries(
          Array.apply(null,Array(10)).map((e,i) => ({ name, amount: i+1 })),
          (data,callback) => {
            Master.findOne({ name: data.name })
              .then(master =>
                Transaction.create({ _asset: master._id, amount: data.amount })
              )
              .then(transaction =>
                Master.update(
                  { _id: transaction._asset },
                  { "$push": {
                    "recent": {
                      "$each": [transaction._id],
                      "$position": 0,
                      "$slice": 5
                    }
                  }}
                )
              )
              .then(res => callback())
              .catch(callback)
          },
          callback
        ),
      callback),

    // Show populated recent 1 entry only
    (callback) =>
      Master.find().select({ 'recent': { '$slice': 1 } })
        .populate('recent').exec((err,results) => {
        if (err) callback(err);
        log(results);
        callback();
      }),

    // Populate recent - page 1 then fetch next page
    (callback) =>
      async.waterfall(
        [
          (callback) =>
            Master.findOne({ name: 'One' }).populate('recent')
              .lean()
              .exec((err,master) => {
                if (err) callback(err);
                log(master);
                callback(null,{
                  _asset: master._id,
                  exclude: master.recent.map( r => r._id )
                });
              }),

          (options,callback) =>
            Transaction.find({
              _asset: options._asset,
              _id: { '$nin': options.exclude }
            }).sort({ 'createdAt': -1 }).limit(5)
            .exec((err,transactions) => {
              if (err) callback(err);
              log(transactions)
              callback();
            })

        ],
        callback
      ),

    // Issue 4321 - Fix - Manual populate with aggregate
    (callback) =>
      Master.find().select('-recent').exec()
        .then(masters => {
          // Get latest transactions for each master
          Transaction.aggregate([
            { '$match': {
              '_asset': {
                '$in': masters.map(m => m._id)
              }
            }},
            { '$sort': { '_asset': 1, 'createdAt': -1 } },
            { '$group': {
              '_id': '$_asset',
              'amount': { '$first': '$amount' },
              'createdAt': { '$first': '$createdAt' },
              'updatedAt': { '$first': '$updatedAt' },
              'did': { '$first': '$_id' }
            }},
            { '$project': {
              '_id': '$did',
              '_asset': '$_id',
              'amount': 1,
              'createdAt': 1,
              'updatedAt': 1
            }}
          ]).exec((err,transactions) => {
            // Map latest transactions to master
            masters = masters.map(
              m => Object.assign(
                m.toObject(),
                {
                  transactions: transactions.filter(
                    t => t._asset.toHexString() === m._id.toHexString()
                  )
                }
              )
            );

            log(masters);
            callback();
          })
        }).catch(callback)

  ],
  (err) => {
    if (err) throw err;
    mongoose.disconnect();
  }
);

演示输出

Mongoose: transactions.remove({}, {})
Mongoose: masters.remove({}, {})
Mongoose: masters.insertMany([ { __v: 0, name: 'One', _id: 5959e34adf833e1451a32661, recent: [] }, { __v: 0, name: 'Two', _id: 5959e34adf833e1451a32662, recent: [] } ], null)
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: masters.findOne({ name: 'Two' }, { fields: {} })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:14 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:14 GMT"), _asset: ObjectId("5959e34adf833e1451a32662"), amount: 1, _id: ObjectId("5959e34adf833e1451a32663"), __v: 0 })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32661"), amount: 1, _id: ObjectId("5959e34adf833e1451a32664"), __v: 0 })
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32661") }, { '$push': { recent: { '$each': [ ObjectId("5959e34adf833e1451a32664") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32662") }, { '$push': { recent: { '$each': [ ObjectId("5959e34adf833e1451a32663") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: masters.findOne({ name: 'Two' }, { fields: {} })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32662"), amount: 2, _id: ObjectId("5959e34bdf833e1451a32665"), __v: 0 })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32661"), amount: 2, _id: ObjectId("5959e34bdf833e1451a32666"), __v: 0 })
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32661") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32666") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32662") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32665") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: masters.findOne({ name: 'Two' }, { fields: {} })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32662"), amount: 3, _id: ObjectId("5959e34bdf833e1451a32667"), __v: 0 })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32661"), amount: 3, _id: ObjectId("5959e34bdf833e1451a32668"), __v: 0 })
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32661") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32668") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32662") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32667") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: masters.findOne({ name: 'Two' }, { fields: {} })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32662"), amount: 4, _id: ObjectId("5959e34bdf833e1451a32669"), __v: 0 })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32661"), amount: 4, _id: ObjectId("5959e34bdf833e1451a3266a"), __v: 0 })
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32661") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a3266a") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32662") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32669") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: masters.findOne({ name: 'Two' }, { fields: {} })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32662"), amount: 5, _id: ObjectId("5959e34bdf833e1451a3266b"), __v: 0 })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32661"), amount: 5, _id: ObjectId("5959e34bdf833e1451a3266c"), __v: 0 })
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32661") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a3266c") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32662") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a3266b") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: masters.findOne({ name: 'Two' }, { fields: {} })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32662"), amount: 6, _id: ObjectId("5959e34bdf833e1451a3266d"), __v: 0 })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32661"), amount: 6, _id: ObjectId("5959e34bdf833e1451a3266e"), __v: 0 })
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32661") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a3266e") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32662") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a3266d") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: masters.findOne({ name: 'Two' }, { fields: {} })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32662"), amount: 7, _id: ObjectId("5959e34bdf833e1451a3266f"), __v: 0 })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32661"), amount: 7, _id: ObjectId("5959e34bdf833e1451a32670"), __v: 0 })
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32661") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32670") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32662") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a3266f") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: masters.findOne({ name: 'Two' }, { fields: {} })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32662"), amount: 8, _id: ObjectId("5959e34bdf833e1451a32671"), __v: 0 })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32661"), amount: 8, _id: ObjectId("5959e34bdf833e1451a32672"), __v: 0 })
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32661") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32672") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32662") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32671") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: masters.findOne({ name: 'Two' }, { fields: {} })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32662"), amount: 9, _id: ObjectId("5959e34bdf833e1451a32673"), __v: 0 })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32661"), amount: 9, _id: ObjectId("5959e34bdf833e1451a32674"), __v: 0 })
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32661") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32674") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32662") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32673") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: masters.findOne({ name: 'Two' }, { fields: {} })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32662"), amount: 10, _id: ObjectId("5959e34bdf833e1451a32675"), __v: 0 })
Mongoose: transactions.insert({ updatedAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), createdAt: new Date("Mon, 03 Jul 2017 06:25:15 GMT"), _asset: ObjectId("5959e34adf833e1451a32661"), amount: 10, _id: ObjectId("5959e34bdf833e1451a32676"), __v: 0 })
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32661") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32676") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.update({ _id: ObjectId("5959e34adf833e1451a32662") }, { '$push': { recent: { '$each': [ ObjectId("5959e34bdf833e1451a32675") ], '$slice': 5, '$position': 0 } } }, {})
Mongoose: masters.find({}, { fields: { recent: { '$slice': 1 } } })
Mongoose: transactions.find({ _id: { '$in': [ ObjectId("5959e34bdf833e1451a32676"), ObjectId("5959e34bdf833e1451a32675") ] } }, { fields: {} })
[
  {
    "_id": "5959e34adf833e1451a32661",
    "__v": 0,
    "name": "One",
    "recent": [
      {
        "_id": "5959e34bdf833e1451a32676",
        "updatedAt": "2017-07-03T06:25:15.282Z",
        "createdAt": "2017-07-03T06:25:15.282Z",
        "_asset": "5959e34adf833e1451a32661",
        "amount": 10,
        "__v": 0
      }
    ]
  },
  {
    "_id": "5959e34adf833e1451a32662",
    "__v": 0,
    "name": "Two",
    "recent": [
      {
        "_id": "5959e34bdf833e1451a32675",
        "updatedAt": "2017-07-03T06:25:15.280Z",
        "createdAt": "2017-07-03T06:25:15.280Z",
        "_asset": "5959e34adf833e1451a32662",
        "amount": 10,
        "__v": 0
      }
    ]
  }
]
Mongoose: masters.findOne({ name: 'One' }, { fields: {} })
Mongoose: transactions.find({ _id: { '$in': [ ObjectId("5959e34bdf833e1451a32676"), ObjectId("5959e34bdf833e1451a32674"), ObjectId("5959e34bdf833e1451a32672"), ObjectId("5959e34bdf833e1451a32670"), ObjectId("5959e34bdf833e1451a3266e") ] } }, { fields: {} })
{
  "_id": "5959e34adf833e1451a32661",
  "__v": 0,
  "name": "One",
  "recent": [
    {
      "_id": "5959e34bdf833e1451a32676",
      "updatedAt": "2017-07-03T06:25:15.282Z",
      "createdAt": "2017-07-03T06:25:15.282Z",
      "_asset": "5959e34adf833e1451a32661",
      "amount": 10,
      "__v": 0
    },
    {
      "_id": "5959e34bdf833e1451a32674",
      "updatedAt": "2017-07-03T06:25:15.264Z",
      "createdAt": "2017-07-03T06:25:15.264Z",
      "_asset": "5959e34adf833e1451a32661",
      "amount": 9,
      "__v": 0
    },
    {
      "_id": "5959e34bdf833e1451a32672",
      "updatedAt": "2017-07-03T06:25:15.216Z",
      "createdAt": "2017-07-03T06:25:15.216Z",
      "_asset": "5959e34adf833e1451a32661",
      "amount": 8,
      "__v": 0
    },
    {
      "_id": "5959e34bdf833e1451a32670",
      "updatedAt": "2017-07-03T06:25:15.195Z",
      "createdAt": "2017-07-03T06:25:15.195Z",
      "_asset": "5959e34adf833e1451a32661",
      "amount": 7,
      "__v": 0
    },
    {
      "_id": "5959e34bdf833e1451a3266e",
      "updatedAt": "2017-07-03T06:25:15.180Z",
      "createdAt": "2017-07-03T06:25:15.180Z",
      "_asset": "5959e34adf833e1451a32661",
      "amount": 6,
      "__v": 0
    }
  ]
}
Mongoose: transactions.find({ _id: { '$nin': [ ObjectId("5959e34bdf833e1451a32676"), ObjectId("5959e34bdf833e1451a32674"), ObjectId("5959e34bdf833e1451a32672"), ObjectId("5959e34bdf833e1451a32670"), ObjectId("5959e34bdf833e1451a3266e") ] }, _asset: ObjectId("5959e34adf833e1451a32661") }, { sort: { createdAt: -1 }, limit: 5, fields: {} })
[
  {
    "_id": "5959e34bdf833e1451a3266c",
    "updatedAt": "2017-07-03T06:25:15.164Z",
    "createdAt": "2017-07-03T06:25:15.164Z",
    "_asset": "5959e34adf833e1451a32661",
    "amount": 5,
    "__v": 0
  },
  {
    "_id": "5959e34bdf833e1451a3266a",
    "updatedAt": "2017-07-03T06:25:15.135Z",
    "createdAt": "2017-07-03T06:25:15.135Z",
    "_asset": "5959e34adf833e1451a32661",
    "amount": 4,
    "__v": 0
  },
  {
    "_id": "5959e34bdf833e1451a32668",
    "updatedAt": "2017-07-03T06:25:15.080Z",
    "createdAt": "2017-07-03T06:25:15.080Z",
    "_asset": "5959e34adf833e1451a32661",
    "amount": 3,
    "__v": 0
  },
  {
    "_id": "5959e34bdf833e1451a32666",
    "updatedAt": "2017-07-03T06:25:15.039Z",
    "createdAt": "2017-07-03T06:25:15.039Z",
    "_asset": "5959e34adf833e1451a32661",
    "amount": 2,
    "__v": 0
  },
  {
    "_id": "5959e34adf833e1451a32664",
    "updatedAt": "2017-07-03T06:25:15.009Z",
    "createdAt": "2017-07-03T06:25:15.009Z",
    "_asset": "5959e34adf833e1451a32661",
    "amount": 1,
    "__v": 0
  }
]
Mongoose: masters.find({}, { fields: { recent: 0 } })
Mongoose: transactions.aggregate([ { '$match': { _asset: { '$in': [ 5959e34adf833e1451a32661, 5959e34adf833e1451a32662 ] } } }, { '$sort': { _asset: 1, createdAt: -1 } }, { '$group': { _id: '$_asset', amount: { '$first': '$amount' }, createdAt: { '$first': '$createdAt' }, updatedAt: { '$first': '$updatedAt' }, did: { '$first': '$_id' } } }, { '$project': { _id: '$did', _asset: '$_id', amount: 1, createdAt: 1, updatedAt: 1 } } ], {})
[
  {
    "_id": "5959e34adf833e1451a32661",
    "__v": 0,
    "name": "One",
    "transactions": [
      {
        "amount": 10,
        "createdAt": "2017-07-03T06:25:15.282Z",
        "updatedAt": "2017-07-03T06:25:15.282Z",
        "_id": "5959e34bdf833e1451a32676",
        "_asset": "5959e34adf833e1451a32661"
      }
    ]
  },
  {
    "_id": "5959e34adf833e1451a32662",
    "__v": 0,
    "name": "Two",
    "transactions": [
      {
        "amount": 10,
        "createdAt": "2017-07-03T06:25:15.280Z",
        "updatedAt": "2017-07-03T06:25:15.280Z",
        "_id": "5959e34bdf833e1451a32675",
        "_asset": "5959e34adf833e1451a32662"
      }
    ]
  }
]

关于node.js - Mongoose 用排序和限制填充虚拟，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44877203/

Mongoose node 34 39 ObjectId node.js mongodb mongodb-query

有关node.js - Mongoose 用排序和限制填充虚拟的更多相关文章

ruby - 什么是填充的 Base64 编码字符串以及如何在 ruby 中生成它们？ - 2
我正在使用的第三方API的文档状态:"[O]urAPIonlyacceptspaddedBase64encodedstrings."什么是“填充的Base64编码字符串”以及如何在Ruby中生成它们。下面的代码是我第一次尝试创建转换为Base64的JSON格式数据。xa=Base64.encode64(a.to_json) 最佳答案他们说的padding其实就是Base64本身的一部分。它是末尾的“=”和“==”。Base64将3个字节的数据包编码为4个编码字符。所以如果你的输入数据有长度n和n%3=1=>"=="末尾用于填充n%
ruby - 匹配大写字母并用后续字母填充，直到一定的字符串长度 - 2
我有一个驼峰式字符串，例如:JustAString。我想按照以下规则形成长度为4的字符串:抓取所有大写字母；如果超过4个大写字母，只保留前4个；如果少于4个大写字母，则将最后大写字母后的字母大写并添加字母，直到长度变为4。以下是可能发生的3种情况:ThisIsMyString将产生TIMS(大写字母)；ThisIsOneVeryLongString将产生TIOV(前4个大写字母)；MyString将生成MSTR(大写字母+tr大写)。我设法用这个片段解决了前两种情况:str.scan(/[A-Z]/).first(4).join但是，我不太确定如何最好地修改上面的代码片段以处理最后一种
在VMware16虚拟机安装Ubuntu详细教程 - 2
在VMware16.2.4安装Ubuntu一、安装VMware1.打开VMwareWorkstationPro官网，点击即可进入。2.进入后向下滑动找到Workstation16ProforWindows，点击立即下载。3.下载完成，文件大小615MB，如下图：4.鼠标右击，以管理员身份运行。5.点击下一步6.勾选条款，点击下一步7.先勾选，再点击下一步8.去掉勾选，点击下一步9.点击下一步10.点击安装11.点击许可证12.在百度上搜索VM16许可证，复制填入，然后点击输入即可，亲测有效。13.点击完成14.重启系统，点击是15.双击VMwareWorkstationPro图标，进入虚拟机主
kvm虚拟机安装centos7基于ubuntu20.04系统 - 2
需求：要创建虚拟机，就需要给他提供一个虚拟的磁盘，我们就在/opt目录下创建一个10G大小的raw格式的虚拟磁盘CentOS-7-x86_64.raw命令格式：qemu-imgcreate-f磁盘格式磁盘名称磁盘大小qemu-imgcreate-f磁盘格式-o?1.创建磁盘qemu-imgcreate-fraw/opt/CentOS-7-x86_64.raw10G执行效果#ls/opt/CentOS-7-x86_64.raw2.安装虚拟机使用virt-install命令，基于我们提供的系统镜像和虚拟磁盘来创建一个虚拟机，另外在创建虚拟机之前，提前打开vnc客户端，在创建虚拟机的时候，通过vnc
ruby-on-rails - 需要帮助最大化多个相似对象中的 3 个因素并适当排序 - 2
我需要用任何语言编写一个算法，根据3个因素对数组进行排序。我以度假村为例(如Hipmunk)。假设我想去度假。我想要最便宜的地方、最好的评论和最多的景点。但是，显然我找不到在所有3个中都排名第一的方法。Example(assumingthereare20importantattractions):ResortA:$150/night...98/100infavorablereviews...18of20attractionsResortB:$99/night...85/100infavorablereviews...12of20attractionsResortC:$120/night
ruby-on-rails - 在具有 ActiveRecord 条件的相关模型中按字段排序 - 2
我正在尝试按Rails相关模型中的字段进行排序。我研究的所有解决方案都没有解决如果相关模型被另一个参数过滤？元素模型classItem相关模型:classPriority我正在使用where子句检索项目:@items=Item.where('company_id=?andapproved=?',@company.id,true).all我需要按相关表格中的“位置”列进行排序。问题在于，在优先级模型中，一个项目可能会被多家公司列出。因此，这些职位取决于他们拥有的company_id。当我显示项目时，它是针对一个公司的，按公司内的职位排序。完成此任务的正确方法是什么？感谢您的帮助。PS-我
ruby - 按数字(从大到大)然后按字母(字母顺序)对对象集合进行排序 - 2
我正在构建一个小部件来显示奥运会的奖牌数。我有一个“国家”对象的集合，其中每个对象都有一个“名称”属性，以及奖牌计数的“金”、“银”、“铜”。列表应该排序:1.首先是奖牌总数2.如果奖牌相同，按类型分割(金>银>铜，即2金>1金+1银)3.如果奖牌和类型相同，则按字母顺序子排序我正在用ruby做这件事，但我想语言并不重要。我确实找到了一个解决方案，但如果感觉必须有更优雅的方法来实现它。这是我做的:使用加权奖牌总数创建一个虚拟属性。因此，如果他们有2个金牌和1个银牌，加权总数将为“3.020100”。1金1银1铜为“3.010101”由于我们希望将奖牌数排序为最高的，因此列表按降序排
ruby - 如何用递增的值填充数组 Ruby - 2
我正在尝试解决http://projecteuler.net/problem=1.我想创建一个方法，它接受一个整数，然后创建一个包含它前面的所有整数的数组，并将整数本身作为数组中的值。以下是我目前所拥有的。代码不起作用。defmake_array(num)numbers=Array.newnumcount=1numbers.eachdo|number|numbers 最佳答案 (1..num).to_a是您在Ruby中需要做的全部。1..num将创建一个Range对象，以1开始并以任意值num结束是。Range对象有to_a方法通过
ruby-on-rails - 在不重新查询数据库的情况下重新排序 Rails 中的事件记录？ - 2
例如，假设我有一个名为Products的模型，并且在ProductsController中，我有以下代码用于product_listView以显示已排序的产品。@products=Product.order(params[:order_by])让我们想象一下，在product_listView中，用户可以使用下拉菜单按价格、评级、重量等进行排序。数据库中的产品不会经常更改。我很难理解的是，每次用户选择新的order_by过滤器时，rails是否必须查询，或者rails是否能够以某种方式缓存事件记录以在服务器端重新排序？有没有一种方法可以编写它，以便在用户排序时rails不会重新查询结果
ruby-on-rails - RoR中是否有任何内置方法可以为整数填充零？ - 2
如果我想要“00001”而不是“1”，除了我自己写填零方法之外，有没有内置的方法可以帮助我为整数填零？最佳答案 puts"%05d"%1#00001参见:String::%,Kernel::sprintf这是正在发生的事情。%左侧的"%05d"是C风格的格式说明符。%右边的变量就是要格式化的东西。格式说明符可以像这样解码:%-格式说明符的开头0-用前导零填充5-长度为5个字符d-被格式化的是一个整数如果你要格式化多个东西，你会把它们放在一个数组中:"%d-%s"%[1,"One"]#=>1-one

node.js - Mongoose 用排序和限制填充虚拟

有关node.js - Mongoose 用排序和限制填充虚拟的更多相关文章

随机推荐