获取 id 数组中具有匹配 id 的所有元素

Question

我在 Express/React Web 应用程序中使用 Mongoose，并将数据存储在 Mongo 数据库中。

我将“歌曲”存储在歌曲集合中，用户有一个包含他听过的歌曲的 id 的数组。

然后为了呈现他一直在听的内容，我必须将数组与歌曲 id 与歌曲集合中的歌曲 id 链接起来。

我目前正在使用

song.find({_id: {$in: ids}}).exec(callback)

获取与 'ids' 数组中的 id 匹配的所有歌曲。如果用户一次又一次地听这首歌，“ids”数组可能多次包含相同的 id。

问题是猫鼬只返回与 id 对应的歌曲一次，因此歌曲不会多次显示。有没有办法告诉猫鼬将重复的 id 传递给回调函数？

总结：

ids: ['a', 'a', 'a', 'b', 'c']
song.find({_id: {$in: ids}}).exec(callback)
dataPassedToCallback: [songA, songB, songC]

期待

dataPassedToCallback: [songA, songA, songA, songB, songC]

Answer 1

关于您可能会问的问题，这里似乎有几种可能的情况。

从 的角度来看$in，MongoDB 确实将其视为$or条件的“简写”，因此这两个语句非常有效：

"field": { "$in": ["a", "a", "a", "b", "c"] }

和

"$or": [
  { "field": "a" },
  { "field": "a" },
  { "field": "a" },
  { "field": "b" },
  { "field": "c" }
]

至少就“他们选择的文档”而言，这仅仅是数据库实际包含的“单个”文档。这里$in实际上更优化一些，因为查询引擎可以看到 OR 在“相同的键”上，这在查询计划执行中节省了一些成本。

另外，请注意可以查看的实际“查询计划执行”explain()实际上会显示无论如何删除了“重复”条目：

        "filter" : {
                "_id" : {
                        "$in" : [
                                "a",
                                "b",
                                "c"
                        ]
                }
        },

值得注意的是，虽然$or实际上不会删除条件，这实际上只是为什么$in在这里作为查询更有效的另一点，即使如此，$or仍然不会多次获得相同的匹配文档。

但是从“选择”的角度来看，那么“多次”要求相同的标准并不会导致检索“多次”。参数的顺序也是如此，因为它们对从数据库本身返回顺序的方式没有影响。从“数据库”的角度实际检索“多个副本”也没有任何意义，因为这基本上是多余的。

相反，您真正要问的是“我有一个列表，现在我想用数据库中的文档替换这些值”。这实际上是一个合理的要求，并且相对容易实现。您的实际实现实际上仅取决于您从何处获取数据。

映射结果

如果您有来自外部源的“列表”并想要数据库对象，那么合乎逻辑的做法是返回匹配的文档，然后用返回的文档替换到您的有序列表中。

在现代 NodeJS 环境中，这很简单：

let list = ["a", "a", "a", "b", "c"];
let songs = await Song.find({ "_id": { "$in": list } });

songs = list.map(e => songs.find(s => s._id === e));

现在songs列表中的每个项目都有一个条目，list顺序相同，但实际上返回的是真实的数据库文档。

如果您正在处理 中的实际ObjectId值_id，那么最好“转换”列表中的值并使用该ObjectId.equals()函数来比较“对象”：

// of course not "valid" ObjectId here; but
let list = ["a", "a", "a", "b", "c"].map(e => ObjectId(e));     // casting
let songs = await Song.find({ "_id": { "$in": list } });

songs = list.map(e => songs.find(s => s._id.equals(e)));        // compare

如果没有async/await从 NodeJS 8.x 版本默认启用的关键字或在早期版本中明确启用，那么标准的 Promise 解析将执行以下操作：

// of course not "valid" ObjectId here; but
let list = ["a", "a", "a", "b", "c"].map(e => ObjectId(e));     // casting

Song.find({ "_id": { "$in": list } }).then(songs =>
  list.map(e => songs.find(s => s._id.equals(e)))              // compare
).then(songs => {
  // do something
})

或者用回调

let list = ["a", "a", "a", "b", "c"].map(e => ObjectId(e));     // casting
Song.find({ "_id": { "$in": list } },(err,songs) => {
  songs = list.map(e => songs.find(s => s._id.equals(e)));     // compare
})

请注意，这与对该问题的评论中提到的“映射函数”有很大不同。真的是中没有点“要求数据库多次”当你已经从返回的结果“一”的请求。因此做这样的事情：

let songs = await Promise.all(list.map(_id => Song.findById(_id)));

这是非常多余的，并且仅仅为了执行请求而创建额外的请求和开销。因此，您不会这样做，而是执行“一个”请求并“重新映射”到列表中，因为这最有意义。

更重要的是，您拥有的实际实现是这种“重新映射”在 API 的这个级别上仍然没有位置。真正应该发生的是“理想情况下”您的“前端”实际上使用“唯一”_id列表“仅”发出请求。然后请求被传递，允许数据库响应并简单地返回匹配的文档。作为工作流程：

Front End              Back End                            Front End
---------              ------------                        -------
List -> Unique List -> Endpoint => Database => Endpoint -> Doc List -> Remap List

因此，从服务器“端点”和“数据库”的角度来看，返回的“文档”应该是它们处理的全部内容。这通过删除所有重复项来减少请求中网络流量的有效负载。只有在收到样本中“三个”文档的响应时在“前端”处理时，您才会真正“重新映射”到包含重复副本的最终列表。

填充

另一方面，如果您实际上正在使用文档中已经包含的数据，那么 Mongoose 已经支持这一点，其中您的“列表”已经是文档中的一个数组。例如作为SongList模型的文档：

{
  "list": ["a", "a", "a", "b", "c"]
}

在“列表”实际上是对Song模型项的引用列表的地方调用 populate将返回每个“副本”，并且为了将文档中的列表存储为：

SongList.find().populate('list')

这样做的原因.populate()基本上是$in使用"list"文档字段中找到的参数，无论如何都会发出相同的查询。然后这些查询结果实际上使用与上面演示的基本完全相同的代码“映射”到该数组上。

因此，如果这是您的实际用例，那么这已经是“内置”的，无需自己执行查询：

下面显示了添加“三首”歌曲并使用相同的“映射”技术以及显示populate()自动执行的操作的示例列表

const { Schema, Types: { ObjectId } } = mongoose = require('mongoose');
const { uniq } = require('lodash');

const uri = 'mongodb://localhost/songs';

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

const songSchema = new Schema({
  name: String
});

const songListSchema = new Schema({
  list: [{ type: Schema.Types.ObjectId, ref: 'Song' }]
});

const Song = mongoose.model('Song', songSchema);

const SongList = mongoose.model('SongList', songListSchema);

const log = data => console.log(JSON.stringify(data, undefined, 2));

(async function() {

  try {

    const conn = await mongoose.connect(uri);
    const db = conn.connections[0].db;

    let { version } = await db.command({ "buildInfo": 1 });
    version = parseFloat(version.match(new RegExp(/(?:(?!-).)*/))[0]);

    await Promise.all(Object.entries(conn.models).map(([k,m]) => m.remove()));

    let [a,b,c] = await Song.insertMany(['a','b','c'].map(name => ({ name })));

    await SongList.create({ list: [ a, a, b, a, c ] });


    // populate is basically mapping the list
    let popresult = await SongList.find().populate('list');
    log({ popresult });


    // Using an id list
    let list = [a, a, b, a, c].map(e => e._id);

    // Use a unique copy for the $in to save bandwidth
    let unique = uniq(list);


    // Map the result
    let songs = await Song.find({ _id: { $in: unique } });
    songs = list.map(e => songs.find(s => s._id.equals(e)));
    log({ songs })


    if ( version >= 3.4 ) {
    // Force the server to return copies
      let stupid = await Song.aggregate([
        { "$match": { "_id": { "$in": unique } } },
        { "$addFields": {
          "copies": {
            "$filter": {
              "input": {
                "$map": {
                  "input": {
                    "$zip":  {
                      "inputs": [
                        { "$literal": list },
                        { "$range": [0, { "$size": { "$literal": list } } ] }
                      ]
                    }
                  },
                  "in": {
                    "_id": { "$arrayElemAt": [ "$$this", 0 ] },
                    "idx": { "$arrayElemAt": [ "$$this", 1 ] }
                  }
                }
              },
              "cond": { "$eq": ["$$this._id", "$_id"] }
            }
          }
        }},
        { "$unwind": "$copies" },
        { "$sort": { "copies.idx": 1 } },
        { "$project": { "copies": 0 } }
      ]);
      log({ stupid })

    }

  } catch(e) {
    console.error(e)
  } finally {
    process.exit()
  }


})()

这为您提供如下输出：

Mongoose: songs.remove({}, {})
Mongoose: songlists.remove({}, {})
Mongoose: songs.insertMany([ { _id: 5b06c2ff373eb00d9610aa6e, name: 'a', __v: 0 }, { _id: 5b06c2ff373eb00d9610aa6f, name: 'b', __v: 0 }, { _id: 5b06c2ff373eb00d9610aa70, name: 'c', __v: 0 } ], {})
Mongoose: songlists.insertOne({ list: [ ObjectId("5b06c2ff373eb00d9610aa6e"), ObjectId("5b06c2ff373eb00d9610aa6e"), ObjectId("5b06c2ff373eb00d9610aa6f"), ObjectId("5b06c2ff373eb00d9610aa6e"), ObjectId("5b06c2ff373eb00d9610aa70") ], _id: ObjectId("5b06c2ff373eb00d9610aa71"), __v: 0 })
Mongoose: songlists.find({}, { fields: {} })
Mongoose: songs.find({ _id: { '$in': [ ObjectId("5b06c2ff373eb00d9610aa6e"), ObjectId("5b06c2ff373eb00d9610aa6f"), ObjectId("5b06c2ff373eb00d9610aa70") ] } }, { fields: {} })
{
  "popresult": [
    {
      "list": [
        {
          "_id": "5b06c2ff373eb00d9610aa6e",
          "name": "a",
          "__v": 0
        },
        {
          "_id": "5b06c2ff373eb00d9610aa6e",
          "name": "a",
          "__v": 0
        },
        {
          "_id": "5b06c2ff373eb00d9610aa6f",
          "name": "b",
          "__v": 0
        },
        {
          "_id": "5b06c2ff373eb00d9610aa6e",
          "name": "a",
          "__v": 0
        },
        {
          "_id": "5b06c2ff373eb00d9610aa70",
          "name": "c",
          "__v": 0
        }
      ],
      "_id": "5b06c2ff373eb00d9610aa71",
      "__v": 0
    }
  ]
}
Mongoose: songs.find({ _id: { '$in': [ ObjectId("5b06c2ff373eb00d9610aa6e"), ObjectId("5b06c2ff373eb00d9610aa6f"), ObjectId("5b06c2ff373eb00d9610aa70") ] } }, { fields: {} })
{
  "songs": [
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6f",
      "name": "b",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa70",
      "name": "c",
      "__v": 0
    }
  ]
}
Mongoose: songs.aggregate([ { '$match': { _id: { '$in': [ 5b06c2ff373eb00d9610aa6e, 5b06c2ff373eb00d9610aa6f, 5b06c2ff373eb00d9610aa70 ] } } }, { '$addFields': { copies: { '$filter': { input: { '$map': { input: { '$zip': { inputs: [ { '$literal': [Array] }, { '$range': [Array] } ] } }, in: { _id: { '$arrayElemAt': [ '$$this', 0 ] }, idx: { '$arrayElemAt': [ '$$this', 1 ] } } } }, cond: { '$eq': [ '$$this._id', '$_id' ] } } } } }, { '$unwind': '$copies' }, { '$sort': { 'copies.idx': 1 } }, { '$project': { copies: 0 } } ], {})
{
  "stupid": [
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6f",
      "name": "b",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa70",
      "name": "c",
      "__v": 0
    }
  ]
}

“愚蠢”的聚合技巧

这真的不是一个解决方案，而是在其他人提到它或类似的东西之前就该主题发表更多的帖子。

更多地归入“愚蠢的技巧”类别实际上是迫使服务器返回文档的“副本”。

let stupid = await Song.aggregate([
  { "$match": { "_id": { "$in": list } } },
  { "$addFields": {
    "copies": {
      "$filter": {
        "input": {
          "$map": {
            "input": {
              "$zip":  {
                "inputs": [
                  list,
                  { "$range": [0, { "$size": { "$literal": list } } ] }
                ]
              }
            },
            "in": {
              "_id": { "$arrayElemAt": [ "$$this", 0 ] },
              "idx": { "$arrayElemAt": [ "$$this", 1 ] }
            }
          }
        },
        "cond": { "$eq": ["$$this._id", "$_id"] }
      }
    }
  }},
  { "$unwind": "$copies" },
  { "$sort": { "copies.idx": 1 } },
  { "$project": { "copies": 0 } }
]);

这实际上将从服务器返回所有文档“副本”。它通过$unwind处理列表输出$filter来实现，只保留那些与当前文档匹配的值_id。倍数将保留在该数组中，当处理时$unwind有效地为每个数组条目生成文档的“副本”。

作为奖励，我们保留"idx"通过通过映射“索引”位置到数组列表中的项目$zip和$range以下$sort然后将放置在文件中的顺序如何出现在输入列表中，只是模仿Array.map()其正在做在您应该使用的代码中。

然后我们可以简单$project地“排除”那个只作为临时措施存在的字段。

综上所述，做这样的事情并不是一个好主意。正如已经提到的，这样做实际上是在增加有效负载，而在客户端中构建“映射”确实更合乎逻辑。理想情况下是已经提到的“最终”客户端。