对于大于 3.2 的现代 MongoDB，在大多数情况下，您可以使用 $lookup 作为 .populate() 的替代品。这还具有实际“在服务器上”执行连接的优点，而不是 .populate() 所做的实际上是 “多个查询”以“模拟”连接。
所以.populate() 不是真正意义上的“连接”关系数据库是如何做到的。另一方面，$lookup 操作符实际上在服务器上完成工作，并且或多或少类似于 "LEFT JOIN"：
Item.aggregate(
[
{ "$lookup": {
"from": ItemTags.collection.name,
"localField": "tags",
"foreignField": "_id",
"as": "tags"
}},
{ "$unwind": "$tags" },
{ "$match": { "tags.tagName": { "$in": [ "funny", "politics" ] } } },
{ "$group": {
"_id": "$_id",
"dateCreated": { "$first": "$dateCreated" },
"title": { "$first": "$title" },
"description": { "$first": "$description" },
"tags": { "$push": "$tags" }
}}
],
function(err, result) {
// "tags" is now filtered by condition and "joined"
}
)
注意这里的 .collection.name 实际上计算为“字符串”，即分配给模型的 MongoDB 集合的实际名称。由于 mongoose 默认“复数”集合名称，$lookup 需要实际的 MongoDB 集合名称作为参数（因为它是服务器操作），所以这是在 mongoose 代码中使用的一个方便技巧，而不是“硬编码”直接收藏名称。
虽然我们也可以在数组上使用$filter 来删除不需要的项目，但这实际上是最有效的形式，因为Aggregation Pipeline Optimization 用于$lookup 的特殊条件，后跟$unwind 和@ 987654328@条件。
这实际上导致三个流水线阶段合二为一：
{ "$lookup" : {
"from" : "itemtags",
"as" : "tags",
"localField" : "tags",
"foreignField" : "_id",
"unwinding" : {
"preserveNullAndEmptyArrays" : false
},
"matching" : {
"tagName" : {
"$in" : [
"funny",
"politics"
]
}
}
}}
这是高度优化的，因为实际操作“首先过滤要加入的集合”，然后返回结果并“展开”数组。两种方法都被使用，因此结果不会突破 16MB 的 BSON 限制，这是客户端没有的限制。
唯一的问题是它在某些方面似乎“违反直觉”，尤其是当您希望将结果放在数组中时，但这就是 $group 的用途，因为它会重构为原始文档形式。
同样不幸的是，我们此时根本无法以服务器最终使用的相同语法编写$lookup。恕我直言，这是一个需要纠正的疏忽。但就目前而言，简单地使用序列就可以了，并且是具有最佳性能和可扩展性的最可行的选择。
附录 - MongoDB 3.6 及更高版本
虽然这里显示的模式相当优化，因为其他阶段如何进入$lookup，但它确实有一个失败之处在于“LEFT JOIN”通常是两者固有的$lookup 和 populate() 的操作被 $unwind 的 "optimal" 用法所否定，它不保留空数组。您可以添加preserveNullAndEmptyArrays 选项，但这会否定上述“优化” 序列，并且基本上保留所有三个通常在优化中组合的阶段。
MongoDB 3.6 扩展了$lookup 的“更具表现力” 形式，允许“子管道”表达式。这不仅满足了保留“LEFT JOIN”的目标，而且还允许优化查询以减少返回的结果，并且语法大大简化：
Item.aggregate([
{ "$lookup": {
"from": ItemTags.collection.name,
"let": { "tags": "$tags" },
"pipeline": [
{ "$match": {
"tags": { "$in": [ "politics", "funny" ] },
"$expr": { "$in": [ "$_id", "$$tags" ] }
}}
]
}}
])
$expr 用于将声明的“本地”值与“外部”值相匹配，这实际上是 MongoDB 现在使用原始 $lookup 语法在“内部”执行的操作。通过以这种形式表达，我们可以自己定制“子管道”中的初始$match 表达式。
事实上，作为一个真正的“聚合管道”，您几乎可以在这个“子管道”表达式中使用聚合管道执行任何操作，包括将$lookup 的级别“嵌套”到其他相关集合。
进一步的使用有点超出这里问题的范围，但就“嵌套人口”而言，$lookup 的新使用模式允许这大致相同，并且 "很多” 在它的充分使用中更强大。
工作示例
下面给出一个在模型上使用静态方法的例子。一旦实现了该静态方法，调用就变成了：
Item.lookup(
{
path: 'tags',
query: { 'tags.tagName' : { '$in': [ 'funny', 'politics' ] } }
},
callback
)
或者增强一些更现代的甚至变成：
let results = await Item.lookup({
path: 'tags',
query: { 'tagName' : { '$in': [ 'funny', 'politics' ] } }
})
使它在结构上与.populate() 非常相似，但实际上它是在服务器上进行连接。为了完整起见，这里的用法是根据父子案例将返回的数据转换回 mongoose 文档实例。
对于大多数常见情况，它相当简单且易于调整或按原样使用。
注意这里使用async 只是为了运行所附示例的简洁性。实际的实现没有这种依赖。
const async = require('async'),
mongoose = require('mongoose'),
Schema = mongoose.Schema;
mongoose.Promise = global.Promise;
mongoose.set('debug', true);
mongoose.connect('mongodb://localhost/looktest');
const itemTagSchema = new Schema({
tagName: String
});
const itemSchema = new Schema({
dateCreated: { type: Date, default: Date.now },
title: String,
description: String,
tags: [{ type: Schema.Types.ObjectId, ref: 'ItemTag' }]
});
itemSchema.statics.lookup = function(opt,callback) {
let rel =
mongoose.model(this.schema.path(opt.path).caster.options.ref);
let group = { "$group": { } };
this.schema.eachPath(p =>
group.$group[p] = (p === "_id") ? "$_id" :
(p === opt.path) ? { "$push": `$${p}` } : { "$first": `$${p}` });
let pipeline = [
{ "$lookup": {
"from": rel.collection.name,
"as": opt.path,
"localField": opt.path,
"foreignField": "_id"
}},
{ "$unwind": `$${opt.path}` },
{ "$match": opt.query },
group
];
this.aggregate(pipeline,(err,result) => {
if (err) callback(err);
result = result.map(m => {
m[opt.path] = m[opt.path].map(r => rel(r));
return this(m);
});
callback(err,result);
});
}
const Item = mongoose.model('Item', itemSchema);
const ItemTag = mongoose.model('ItemTag', itemTagSchema);
function log(body) {
console.log(JSON.stringify(body, undefined, 2))
}
async.series(
[
// Clean data
(callback) => async.each(mongoose.models,(model,callback) =>
model.remove({},callback),callback),
// Create tags and items
(callback) =>
async.waterfall(
[
(callback) =>
ItemTag.create([{ "tagName": "movies" }, { "tagName": "funny" }],
callback),
(tags, callback) =>
Item.create({ "title": "Something","description": "An item",
"tags": tags },callback)
],
callback
),
// Query with our static
(callback) =>
Item.lookup(
{
path: 'tags',
query: { 'tags.tagName' : { '$in': [ 'funny', 'politics' ] } }
},
callback
)
],
(err,results) => {
if (err) throw err;
let result = results.pop();
log(result);
mongoose.disconnect();
}
)
对于 Node 8.x 及更高版本，使用 async/await 或者更现代一点，并且没有其他依赖项：
const { Schema } = mongoose = require('mongoose');
const uri = 'mongodb://localhost/looktest';
mongoose.Promise = global.Promise;
mongoose.set('debug', true);
const itemTagSchema = new Schema({
tagName: String
});
const itemSchema = new Schema({
dateCreated: { type: Date, default: Date.now },
title: String,
description: String,
tags: [{ type: Schema.Types.ObjectId, ref: 'ItemTag' }]
});
itemSchema.statics.lookup = function(opt) {
let rel =
mongoose.model(this.schema.path(opt.path).caster.options.ref);
let group = { "$group": { } };
this.schema.eachPath(p =>
group.$group[p] = (p === "_id") ? "$_id" :
(p === opt.path) ? { "$push": `$${p}` } : { "$first": `$${p}` });
let pipeline = [
{ "$lookup": {
"from": rel.collection.name,
"as": opt.path,
"localField": opt.path,
"foreignField": "_id"
}},
{ "$unwind": `$${opt.path}` },
{ "$match": opt.query },
group
];
return this.aggregate(pipeline).exec().then(r => r.map(m =>
this({ ...m, [opt.path]: m[opt.path].map(r => rel(r)) })
));
}
const Item = mongoose.model('Item', itemSchema);
const ItemTag = mongoose.model('ItemTag', itemTagSchema);
const log = body => console.log(JSON.stringify(body, undefined, 2));
(async function() {
try {
const conn = await mongoose.connect(uri);
// Clean data
await Promise.all(Object.entries(conn.models).map(([k,m]) => m.remove()));
// Create tags and items
const tags = await ItemTag.create(
["movies", "funny"].map(tagName =>({ tagName }))
);
const item = await Item.create({
"title": "Something",
"description": "An item",
tags
});
// Query with our static
const result = (await Item.lookup({
path: 'tags',
query: { 'tags.tagName' : { '$in': [ 'funny', 'politics' ] } }
})).pop();
log(result);
mongoose.disconnect();
} catch (e) {
console.error(e);
} finally {
process.exit()
}
})()
从 MongoDB 3.6 及更高版本开始，即使没有 $unwind 和 $group 构建：
const { Schema, Types: { ObjectId } } = mongoose = require('mongoose');
const uri = 'mongodb://localhost/looktest';
mongoose.Promise = global.Promise;
mongoose.set('debug', true);
const itemTagSchema = new Schema({
tagName: String
});
const itemSchema = new Schema({
title: String,
description: String,
tags: [{ type: Schema.Types.ObjectId, ref: 'ItemTag' }]
},{ timestamps: true });
itemSchema.statics.lookup = function({ path, query }) {
let rel =
mongoose.model(this.schema.path(path).caster.options.ref);
// MongoDB 3.6 and up $lookup with sub-pipeline
let pipeline = [
{ "$lookup": {
"from": rel.collection.name,
"as": path,
"let": { [path]: `$${path}` },
"pipeline": [
{ "$match": {
...query,
"$expr": { "$in": [ "$_id", `$$${path}` ] }
}}
]
}}
];
return this.aggregate(pipeline).exec().then(r => r.map(m =>
this({ ...m, [path]: m[path].map(r => rel(r)) })
));
};
const Item = mongoose.model('Item', itemSchema);
const ItemTag = mongoose.model('ItemTag', itemTagSchema);
const log = body => console.log(JSON.stringify(body, undefined, 2));
(async function() {
try {
const conn = await mongoose.connect(uri);
// Clean data
await Promise.all(Object.entries(conn.models).map(([k,m]) => m.remove()));
// Create tags and items
const tags = await ItemTag.insertMany(
["movies", "funny"].map(tagName => ({ tagName }))
);
const item = await Item.create({
"title": "Something",
"description": "An item",
tags
});
// Query with our static
let result = (await Item.lookup({
path: 'tags',
query: { 'tagName': { '$in': [ 'funny', 'politics' ] } }
})).pop();
log(result);
await mongoose.disconnect();
} catch(e) {
console.error(e)
} finally {
process.exit()
}
})()