Question

想象一下一个函数，该函数按用户名查找用户并返回用户。

 User.aggregate(
        [
            { $sort: { userFirstName: 1, userLastName: 1 } },
            {
                $addFields: {
                    firstLastName: { $concat: ['$userFirstName', ' ', '$userLastName'] },
                    lastFirstName: { $concat: ['$userLastName', ' ', '$userFirstName'] }
                }
            },
            {
                $match: $match // Set from above with match crit
            },
            {
                $group: {
                    _id: null,
                    total: { $sum: 1 },
                    data: {
                        $push: {
                            '_id': '$_id',
                            'userFirstName': '$userFirstName',
                            'userLastName': '$userLastName',
                            'userProfileImage': '$userProfileImage',
                            'userVihorCategory': '$userVihorCategory'
                        }
                    }
                }
            },
            {
                $project: {
                    total: 1,
                    data: { $slice: ['$data', start, limit] }
                }
            }
        ]
    ).exec((errAgg, results) => {...

这有效，它将它们拼接起来并正确返回它们。还有另一个跟踪用户连接的集合。

{
    user: { type: Schema.Types.ObjectId, ref: 'User' },
    userConnection: { type: Schema.Types.ObjectId, ref: 'User' },
    userConnectionStatus: {
        type: String,
        enum: ['following', 'blocked', 'requested']
    }
}

例如，用户：我，userConnection：“某人”，userConnectionStatus：“正在关注”

我要达到的目标是再返回2个字段， 1.我对他的userConnectionStatus 2.他对我的userConnectionStatus

不要返回阻止我的用户。关于这种数据库结构，最好的方法是什么。

谢谢您的时间

Answer 1

通过选择所有被阻止的用户并在聚合中的匹配项中添加$ nin来解决防止被阻止的用户的问题。

对于连接状态，我已经通过向User添加2个虚拟字段解决了该问题。

UserMongoSchema.virtual('userConnectionStatus', {
  ref: 'UserConnection',
  localField: '_id',
  foreignField: 'user',
  justOne: true
});
UserMongoSchema.virtual('connectionStatus', {
  ref: 'UserConnection',
  localField: '_id',
  foreignField: 'userConnection',
  justOne: true
});

并在结果中填充它们

...
.exec((errAgg, results) => {
      User.populate(results[0].data, [ 
            { path: 'userConnectionStatus', match: { userConnection: req.userCode }, select: 'userConnectionStatus' },
            { path: 'connectionStatus', match: { user: req.userCode }, select: 'userConnectionStatus' },
        ], (errPop, populateResponse) => {
            if (errPop) { return next(errPop); }

            populateResponse = populateResponse.map((row) => {
                row['userConnectionStatus'] = row.userConnectionStatus ? row.userConnectionStatus.userConnectionStatus : null;
                row['connectionStatus'] = row.connectionStatus ? row.connectionStatus.userConnectionStatus : null;
                return row;
            });
...

从动作的顺序来看，我认为这不会影响性能，因为我只在匹配的前X个（最多100个）结果上填充

。

我不会将其标记为“答案”。如果您对这是不好的做法还是有更好的方法有任何意见，请随时发表评论。

返回不同集合猫鼬的字段

1 个答案: