填充 mongoose 中的嵌套数组

如何填充在示例文档中 “components” 的值:

  {
"__v": 1,
"_id": "5252875356f64d6d28000001",
"pages": [
{
"__v": 1,
"_id": "5252875a56f64d6d28000002",
"page": {
"components": [
"525287a01877a68528000001"
]
}
}
],
"author": "Book Author",
"title": "Book Title"
}

这是我的 JS，在这里我可以通过 Mongoose 获得文档:

  Project.findById(id).populate('pages').exec(function(err, project) {
res.json(project);
});
155444 次浏览
小开

这对我很有用:

 Project.find(query)
.lean()
.populate({ path: 'pages' })
.exec(function(err, docs) {


var options = {
path: 'pages.components',
model: 'Component'
};


if (err) return res.json(500);
Project.populate(docs, options, function (err, projects) {
res.json(projects);
});
});

文件: 模型，填充

小开

删除文档引用

if (err) {
return res.json(500);
}
Project.populate(docs, options, function (err, projects) {
res.json(projects);
});

这招对我很管用。

if (err) {
return res.json(500);
}
Project.populate(options, function (err, projects) {
res.json(projects);
});
小开
最佳答案

猫鼬4.5支持这个

Project.find(query)
.populate({
path: 'pages',
populate: {
path: 'components',
model: 'Component'
}
})
.exec(function(err, docs) {});

你可以加入不止一个深层次。

编辑03/17/2021: 这是库的实现，它在后台所做的就是为你做另一个查询来获取东西，然后加入到内存中。虽然这个工作但是我们真的不应该依赖。它将使您的 db 设计看起来像 SQL 表。这是昂贵的操作和规模不好。请尝试设计您的文档，以便它减少连接。

小开

正如其他人所指出的，Mongoose 4支持这一点。需要注意的是，如果需要，还可以递归到比一个级别更深的级别ーー尽管文档中没有注明这一点:

Project.findOne({name: req.query.name})
.populate({
path: 'threads',
populate: {
path: 'messages',
model: 'Message',
populate: {
path: 'user',
model: 'User'
}
}
})
小开

我发现这非常有帮助创建一个羽毛前钩填充2个裁判级别的深入关系。猫鼬模型只是

tables = new Schema({
..
tableTypesB: { type: Schema.Types.ObjectId, ref: 'tableTypesB' },
..
}
tableTypesB = new Schema({
..
tableType: { type: Schema.Types.ObjectId, ref: 'tableTypes' },
..
}

然后在羽毛前钩:

module.exports = function(options = {}) {
return function populateTables(hook) {
hook.params.query.$populate = {
path: 'tableTypesB',
populate: { path: 'tableType' }
}


return Promise.resolve(hook)
}
}

与我试图实现的其他一些方法相比，这是如此的简单。

小开

您可以像这样填充多个嵌套文档。

   Project.find(query)
.populate({
path: 'pages',
populate: [{
path: 'components',
model: 'Component'
},{
path: 'AnotherRef',
model: 'AnotherRef',
select: 'firstname lastname'
}]
})
.exec(function(err, docs) {});
小开

你也可以使用 强 > $lookup强聚合来做到这一点，而且可能现在最好的方法就是从蒙戈种群中灭绝

Project.aggregate([
{ "$match": { "_id": mongoose.Types.ObjectId(id) } },
{ "$lookup": {
"from": Pages.collection.name,
"let": { "pages": "$pages" },
"pipeline": [
{ "$match": { "$expr": { "$in": [ "$_id", "$$pages" ] } } },
{ "$lookup": {
"from": Component.collection.name,
"let": { "components": "$components" },
"pipeline": [
{ "$match": { "$expr": { "$in": [ "$_id", "$$components" ] } } },
],
"as": "components"
}},
],
"as": "pages"
}}
])
小开

我通过另一个问题找到了这个问题，这个问题是 KeystoneJS 特定的，但是被标记为重复的。如果这里有人可能正在寻找 Keystone 的答案，这就是我在 Keystone 中如何进行深度填充查询的。

使用 KeystoneJ 的猫鼬两级种群[重复]

exports.getStoreWithId = function (req, res) {
Store.model
.find()
.populate({
path: 'productTags productCategories',
populate: {
path: 'tags',
},
})
.where('updateId', req.params.id)
.exec(function (err, item) {
if (err) return res.apiError('database error', err);
// possibly more than one
res.apiResponse({
store: item,
});
});
};
小开

对于那些有 populate问题并且也想这样做的人:

  • 用简单的文字和快速的回复(气泡)聊天
  • 4个用于聊天的数据库集合: clients，users，rooms，messasges。
  • 相同的消息数据库结构的3种类型的发件人: 机器人，用户和客户端
  • refPath或 动态参考
  • 带有 path和 model选项的 populate
  • 使用 findOneAndReplace/replaceOne和 $exists
  • 如果获取的文档不存在，则创建一个新文档

背景

进球了

  1. 保存一个新的简单的文本消息到数据库并填充它与用户或客户端数据(2个不同的模型)。
  2. 将一个新的 Quick Replies 消息保存到数据库，并用用户或客户端数据填充它。
  3. 保存每条消息的发件人类型: clients、 users和 bot。
  4. 只填充具有发送方 clients或 users及其猫鼬模型的消息。_ sender 类型的客户端模型是 clients，用户是 users。

消息模式 :

const messageSchema = new Schema({
room: {
type: Schema.Types.ObjectId,
ref: 'rooms',
required: [true, `Room's id`]
},
sender: {
_id: { type: Schema.Types.Mixed },
type: {
type: String,
enum: ['clients', 'users', 'bot'],
required: [true, 'Only 3 options: clients, users or bot.']
}
},
timetoken: {
type: String,
required: [true, 'It has to be a Nanosecond-precision UTC string']
},
data: {
lang: String,
// Format samples on https://docs.chatfuel.com/api/json-api/json-api
type: {
text: String,
quickReplies: [
{
text: String,
// Blocks' ids.
goToBlocks: [String]
}
]
}
}


mongoose.model('messages', messageSchema);

解决方案

我的服务器端 API 请求

我的原则

实用工具函数(在 chatUtils.js文件上)获取要保存的消息类型:

/**
* We filter what type of message is.
*
* @param {Object} message
* @returns {string} The type of message.
*/
const getMessageType = message => {
const { type } = message.data;
const text = 'text',
quickReplies = 'quickReplies';


if (type.hasOwnProperty(text)) return text;
else if (type.hasOwnProperty(quickReplies)) return quickReplies;
};


/**
* Get the Mongoose's Model of the message's sender. We use
* the sender type to find the Model.
*
* @param {Object} message - The message contains the sender type.
*/
const getSenderModel = message => {
switch (message.sender.type) {
case 'clients':
return 'clients';
case 'users':
return 'users';
default:
return null;
}
};


module.exports = {
getMessageType,
getSenderModel
};

我的服务器端(使用 Nodejs)获取保存消息的请求:

app.post('/api/rooms/:roomId/messages/new', async (req, res) => {
const { roomId } = req.params;
const { sender, timetoken, data } = req.body;
const { uuid, state } = sender;
const { type } = state;
const { lang } = data;


// For more info about message structure, look up Message Schema.
let message = {
room: new ObjectId(roomId),
sender: {
_id: type === 'bot' ? null : new ObjectId(uuid),
type
},
timetoken,
data: {
lang,
type: {}
}
};


// ==========================================
//          CONVERT THE MESSAGE
// ==========================================
// Convert the request to be able to save on the database.
switch (getMessageType(req.body)) {
case 'text':
message.data.type.text = data.type.text;
break;
case 'quickReplies':
// Save every quick reply from quickReplies[].
message.data.type.quickReplies = _.map(
data.type.quickReplies,
quickReply => {
const { text, goToBlocks } = quickReply;


return {
text,
goToBlocks
};
}
);
break;
default:
break;
}


// ==========================================
//           SAVE THE MESSAGE
// ==========================================
/**
* We save the message on 2 ways:
* - we replace the message type `quickReplies` (if it already exists on database) with the new one.
* - else, we save the new message.
*/
try {
const options = {
// If the quickRepy message is found, we replace the whole document.
overwrite: true,
// If the quickRepy message isn't found, we create it.
upsert: true,
// Update validators validate the update operation against the model's schema.
runValidators: true,
// Return the document already updated.
new: true
};


Message.findOneAndUpdate(
{ room: roomId, 'data.type.quickReplies': { $exists: true } },
message,
options,
async (err, newMessage) => {
if (err) {
throw Error(err);
}


// Populate the new message already saved on the database.
Message.populate(
newMessage,
{
path: 'sender._id',
model: getSenderModel(newMessage)
},
(err, populatedMessage) => {
if (err) {
throw Error(err);
}


res.send(populatedMessage);
}
);
}
);
} catch (err) {
logger.error(
`#API Error on saving a new message on the database of roomId=${roomId}. ${err}`,
{ message: req.body }
);


// Bad Request
res.status(400).send(false);
}
});

提示信息 :

数据库:

  • 每条信息本身就是一份文档。
  • 我们不使用 refPath，而是使用 populate()上使用的 util getSenderModel。这是因为机器人。该 sender.type可以是: users与他的数据库，clients与他的数据库和 bot没有数据库。refPath需要真正的模型参考，如果不是，猫鼬抛出一个错误。
  • sender._id可以是用户和客户端的 ObjectId类型，也可以是 bot 的 null类型。

对于 API 请求逻辑:

  • 我们替换了 quickReply消息(MessageDB 必须只有一个快速回复，但是需要多少简单的文本消息就有多少)。我们使用 findOneAndUpdate而不是 replaceOne或 findOneAndReplace。
  • 我们使用每个操作的 callback执行查询操作(findOneAndUpdate)和 populate操作。如果你不知道是否使用 async/await，then()，exec()或者 callback(err, document)，这是很重要的。更多信息请看 人口医生。
  • 我们将快速回复消息替换为 overwrite选项，而不使用 $set查询操作符。
  • 如果我们找不到快速回复，我们就创建一个新的。你必须告诉猫鼬这与 upsert选项。
  • 我们只为替换的消息或新保存的消息填充一次。
  • 我们返回回调函数，不管我们用 findOneAndUpdate和 populate()保存的消息是什么。
  • 在 populate中，我们使用 getSenderModel创建一个自定义动态模型引用。我们可以使用猫鼬的动态参考，因为 bot的 sender.type没有任何猫鼬模型。我们使用 跨数据库填充与 model和 path视蛋白。

我已经花了很多时间解决这里那里的小问题，我希望这将有助于某人！

小开

这是最好的解决办法:

Car
.find()
.populate({
path: 'pages.page.components'
})
小开

我挣扎了一整天。以上的解决方案都不管用。在我的例子中，唯一起作用的就是下面这个例子:

{
outerProp1: {
nestedProp1: [
{ prop1: x, prop2: y, prop3: ObjectId("....")},
...
],
nestedProp2: [
{ prop1: x, prop2: y, prop3: ObjectId("....")},
...
]
},
...
}

执行以下操作: (假设在获取之后填充——但是在从 Model 类调用 populate 时也可以工作(后面跟着 exec))

await doc.populate({
path: 'outerProp1.nestedProp1.prop3'
}).execPopulate()


// doc is now populated

换句话说，最外面的路径属性必须包含完整路径。似乎没有与填充属性耦合的部分完整路径(而且模型属性似乎不是必需的; 因为它包含在模式中，所以它是有意义的)。我花了一整天才想明白！不知道为什么其他的例子不起作用。

(使用猫鼬5.5.32)

小开

猫鼬5.4支持这一点

Project.find(query)
.populate({
path: 'pages.page.components',
model: 'Component'
})
小开

如果你想进入更深的层次，以下是你需要做的:

Airlines.findById(id)
.populate({
path: 'flights',
populate:[
{
path: 'planeType',
model: 'Plane'
},
{
path: 'destination',
model: 'Location',
populate: { // deeper
path: 'state',
model: 'State',
populate: { // even deeper
path: 'region',
model: 'Region'
}
}
}]
})
小开

我使用下面的语法是干净的。这个代码块来自我的项目

const result = await Result.find(filter).populate('student exam.subject')

解释

假设你有两个模式

考试模式

const ExamSchema = new mongoose.Schema({
...
type: String,
...
})

结果模式

const resultSchema = new mongoose.Schema({
...
exam: ExamSchema,
student: {
type: mongoose.Schema.Types.ObjectId,
ref: 'User',
required: true
}
})

如果我想查询和填充结果

  1. 只有学生证

    const result = await Result.find(filter).populate('student')

  2. 只按考试类型分类

    const result = await Result.find(filter).populate('exam.type')

  3. 根据学生证和考试类型

    const result = await Result.find(filter).populate('student exam.type')

如果您需要更多的澄清请在评论中询问

小开

用一个层次嵌套的填充和投影来回答问题，您可能会发现它很有趣。

Https://mongoplayground.net/p/2dpezwsxr-v

查询:

db.booking.aggregate([
{
"$match": {
id: "61fdfeef678791001880da25"
}
},
{
$unwind: "$cart"
},
{
"$lookup": {
"from": "products",
"localField": "cart.product",
"foreignField": "id",
"as": "prod"
}
},
{
"$unwind": "$prod"
},
{
"$project": {
id: 1,
status: 1,
cart: [
{
id: "$cart.id",
date: "$cart.date",
timeSlots: "$cart.timeSlots",
product: {
id: "$prod.id",
name: "$prod.name",
            

}
}
],
      

}
}
])

分贝:

db={
"booking": [
{
"status": "0",
"cart": [
{
"id": "61fdffc7678791001880da5f",
"date": "2022-02-05T00:00:00.000Z",
"product": "61fd7bc5801207001b94d949",
"timeSlots": [
{
"id": "61fd7bf2801207001b94d99c",
"spots": 1
}
],
"createdAt": "2022-02-05T04:40:39.155Z",
"updatedAt": "2022-02-05T04:40:39.155Z"
}
],
"version": 1,
"id": "61fdfeef678791001880da25"
}
],
"products": [
{
"meta": {
"timeZone": "America/New_York"
},
"photos": [],
"name": "Guide To Toronto Canada",
"timeSlots": [
{
"id": "61fd7bcf801207001b94d94d",
"discount": null,
"endTime": "2022-02-05T03:01:00.000Z",
"spots": null,
"startTime": "2022-02-04T14:00:00.000Z"
},
{
"id": "61fd7bf2801207001b94d99c",
"discount": null,
"endTime": "2022-02-04T20:18:00.000Z",
"spots": 15,
"startTime": "2022-02-04T19:18:00.000Z"
},
        

],
"mrp": 20,
"id": "61fd7bc5801207001b94d949"
}
]
}
小开

我试过用猫鼬5.10的最新版本

请考虑以下 Schema 定义的用例，然后回顾如何填充

const jobsSchema: Schema = new Schema({
employerId:String
}, {strict : false})


jobsSchema.virtual('employer', {
ref: 'Employer',
localField: 'employerId',
foreignField: '_id',
justOne: true
});

另一个模型是作业视图

const jobsViewSchema: Schema = new Schema({
jobId:String
}, {strict : false})


jobsViewSchema.virtual('job', {
ref: 'Jobs',
localField: 'jobId',
foreignField: '_id',
justOne: true
});

现在开始繁殖

this.JobViewModel.find(query).populate({
path: 'job',
populate: ['employer', 'Virtual2', 'Virtual3']
})

这将完美地填充整个对象。


提交答案