我有两个集合，我们称它们为 Cats 和 Parties，具有以下模式:

猫

{ name: String }

聚会

{ date: Date, attendants: [{ cat: { ref: 'Cat' }, role: String }] }

其中 role 表示其他一些属性，例如，出席的猫是否是 VIP 成员(member)。

现在我想得到一个存在的所有猫的列表(甚至是那些从未参加过任何派对的可怜的小猫)，对于每只猫，我想要一个它曾担任过的所有角色的列表至少一方。此外，我希望整个列表按(每只猫)最后参加派对的日期排序，从未参加任何派对的猫排在最后。

这给我带来了以下问题:

• 对派对 进行汇总排除了从未加入派对的派对小猫。
• 聚合 Cats 有点“走错了路”，因为我不能 $lookup 猫参加的派对，因为该信息在子文档数组中。

我目前拥有的管道为我提供了所有至少参加过一次聚会的猫以及他们的角色列表，但没有按最后参加的聚会排序。事实上，我可以接受排除从未参加过派对的猫，但分类对我来说至关重要:

Party.aggregate([
        { $unwind: '$attendants' },
        { $project: { role: '$attendants.role', cat: '$attendants.cat' } },
        {
            $group: {
                _id: '$cat',
                roles: { $addToSet: '$role' }
            }
        },
        {
            $lookup: {
                from: 'cats',
                localField: '_id',
                foreignField: '_id',
                as: 'cat'
            }
        },
        { $unwind: '$cat' },
        // (*)
        { $addFields: { 'cat.roles': '$roles' } },
        { $replaceRoot: { newRoot: '$cat' } }
])

我目前的想法基本上是在 (*) 处添加一个派对列表，$project 到派对的日期和然后 $group 使用 $max 获取最新日期。然后，我可以 $unwind 现在是单元素数组，最后对其进行 $sort。

问题是 mongo、AFAIK 中不存在正确的外部连接，而且我不知道如何在管道中获取每只猫的参与方列表。

为了澄清，预期的输出应该是这样的

[
    {
        "_id": "59982d3c7ca25936f8c327c8",
        "name": "Mr. Kitty",
        "roles": ["vip", "birthday cat"],
        "dateOfLastParty": "2017-06-02"
    },
    {
        "_id": "59982d3c7ca25936f8c327c9",
        "name": "Snuffles",
        "roles": ["best looking cat"],
        "dateOfLastParty": "2017-06-01"
    },
    ...
    {
        "_id": "59982d3c7ca25936f8c327c4",
        "name": "Sad Face McLazytown",
        "roles": [],
        "dateOfLastParty": null
    },
]

最佳答案

如前所述，您需要“猫”，因此使用Cat 模型并执行$lookup 固有的“左外连接”。 ，而不是从相反的集合中请求“右外连接”，因为此时 MongoDB 不可能进行“右外连接”。

它作为“左连接”也更实用，因为您希望“猫”作为您的主要输出源。链接到“Party”时唯一要考虑的是每个“Cat”都列在一个数组中，因此您会得到整个文档。所以所有需要做的就是在$lookup之后的“后处理”中，您只需“过滤”当前猫的匹配条目的数组内容。

幸运的是，我们通过 $arrayElemAt 获得了很好的特性和 $indexOfArray ，这使我们能够进行精确提取:

let kitties = await Cat.aggregate([
  { '$lookup': {
    'from': Party.collection.name,
    'localField': '_id',
    'foreignField': 'attendants.cat',
    'as': 'parties'
  }},
  { '$replaceRoot': {
    'newRoot': {
      '$let': {
        'vars': {
          'parties': {
            '$map': {
              'input': '$parties',
              'as': 'p',
              'in': {
                'date': '$$p.date',
                'role': {
                  '$arrayElemAt': [
                    '$$p.attendants.role',
                    { '$indexOfArray': [ '$$p.attendants.cat', '$_id' ] }
                  ]
                }
              }
            }
          }
        },
        'in': {
          '_id': '$_id',
          'name': '$name',
          'roles': '$$parties.role',
          'dateOfLastParty': { '$max': '$$parties.date' }
        }
      }
    }
  }}
]);

所以我这里“最佳”处理的概念实际上使用了$replaceRoot在这里是因为您可以在 $let 下定义整个文档陈述。我这样做的原因是我们可以从之前的 $lookup 中获取 "parties" 数组输出并 reshape 每个条目，为该给定方的当前“小猫”提取匹配的 “role” 数据。这个我们其实可以自己做一个变量。

“数组变量”的原因是因为我们可以使用 $max将“最大/最后”日期属性提取为“单数”，并仍然从该 reshape 内容中将“角色”值提取为“数组”。这样可以轻松定义所需的字段。

因为它首先是从 Cat 开始的“左连接”，所以那些错过所有聚会的可怜的小猫仍然存在，并且仍然有所需的输出。

两个聚合流水线阶段。还有什么比这更简单!

作为完整列表:

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

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

const uri = 'mongodb://localhost/catparty',
      options = { useMongoClient: true };

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

const partySchema = new Schema({
  date: Date,
  attendants: [{
    cat: { type: Schema.Types.ObjectId, ref: 'Cat' },
    role: String
  }]
});

const Cat = mongoose.model('Cat', catSchema);
const Party = mongoose.model('Party', partySchema);

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


(async function() {

  try {

    const conn = await mongoose.connect(uri,options);

    // Clean collections
    await Promise.all(
      Object.keys(conn.models).map( m => conn.models[m].remove({}) )
    );


    var cats = await Cat.insertMany(
      ['Fluffy', 'Snuggles', 'Whiskers', 'Socks'].map( name => ({ name }) )
    );

    cats.shift();
    cats = cats.map( (cat,idx) =>
      ({ cat: cat._id, role: (idx === 0) ? 'Host' : 'Guest' })
    );
    log(cats);

    let party = await Party.create({
      date: new Date(),
      attendants: cats
    });

    log(party);

    let kitties = await Cat.aggregate([
      { '$lookup': {
        'from': Party.collection.name,
        'localField': '_id',
        'foreignField': 'attendants.cat',
        'as': 'parties'
      }},
      { '$replaceRoot': {
        'newRoot': {
          '$let': {
            'vars': {
              'parties': {
                '$map': {
                  'input': '$parties',
                  'as': 'p',
                  'in': {
                    'date': '$$p.date',
                    'role': {
                      '$arrayElemAt': [
                        '$$p.attendants.role',
                        { '$indexOfArray': [ '$$p.attendants.cat', '$_id' ] }
                      ]
                    }
                  }
                }
              }
            },
            'in': {
              '_id': '$_id',
              'name': '$name',
              'roles': '$$parties.role',
              'dateOfLastParty': { '$max': '$$parties.date' }
            }
          }
        }
      }}
    ]);

    log(kitties);


  } catch(e) {
    console.error(e);
  } finally {
    mongoose.disconnect();
  }

})();

示例输出:

[
  {
    "_id": "59a00d9528683e0f59e53460",
    "name": "Fluffy",
    "roles": [],
    "dateOfLastParty": null
  },
  {
    "_id": "59a00d9528683e0f59e53461",
    "name": "Snuggles",
    "roles": [
      "Host"
    ],
    "dateOfLastParty": "2017-08-25T11:44:21.903Z"
  },
  {
    "_id": "59a00d9528683e0f59e53462",
    "name": "Whiskers",
    "roles": [
      "Guest"
    ],
    "dateOfLastParty": "2017-08-25T11:44:21.903Z"
  },
  {
    "_id": "59a00d9528683e0f59e53463",
    "name": "Socks",
    "roles": [
      "Guest"
    ],
    "dateOfLastParty": "2017-08-25T11:44:21.903Z"
  }
]

而且您应该能够看到这些“角色”值实际上如何变成包含更多数据的数组。如果你需要它成为一个“唯一列表”，那么只需用 $setDifference 包裹起来如:

'roles': { '$setDifference': [ '$$parties.role', [] ] },

这也包括在内

关于node.js - 聚合管道中的右外连接，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45879348/