如何根据常见的数组元素对文档进行匹配和排序

Question

var UserSchema = Schema (
{
         android_id: String,
         created: {type: Date, default:Date.now},
         interests: [{ type: Schema.Types.ObjectId, ref: 'Interests' }],
});
 Users.aggregate([
        { $match: {android_id: {$ne: userID}, interests: {$elemMatch: {$in: ids}} }},
        { $group: { _id: { android_id: '$android_id'},count: {$sum: 1}}},
        { $sort: {count: -1}},
        { $limit: 5 }], 

我需要找到与我最感兴趣的用户的前5个android_id (id数组)。我也可以使用利益数组中只匹配元素的数组。

Answer 1

您的思路似乎是正确的，但是您确实需要考虑数组对比较有特殊的考虑。

您在这里的基本起点是找到所有不是当前用户的用户，并且您还至少需要当前用户的"兴趣"数组。您似乎已经这样做了，但是在这里，让我们假设您拥有当前用户的整个user对象，该对象将在清单中使用。

这使得你的"前5名"基本上是"不是我，而是最共同的兴趣"的产物，这意味着你基本上需要计算每个用户与当前用户的兴趣"重叠"。

这基本上是返回相同元素的两个数组或"集合"的 $setIntersection 。为了计算共有多少个元素，还有 $size 运算符。所以你可以这样应用:

Users.aggregate(
    [
        { "$match": {
            "android_id": { "$ne": user.android_id },
            "interests": { "$in": user.interests }
        }},
        { "$project": {
            "android_id": 1,
            "interests": 1,
            "common": {
                "$size": {
                    "$setIntersection": [ "$interests", user.interests ]
                }
            }
        }},
        { "$sort": { "common": -1 } },
        { "$limit": 5 }
    ],
    function(err,result) {
    }
);

"common"返回的结果是当前用户和数据中被检查的用户之间的共同兴趣的计数。然后，该数据由 $sort 处理，以便将最大数量的共同兴趣放在顶部，然后 $limit 仅返回前5个。

如果出于某种原因，您的MongoDB版本目前低于MongoDB 2.6，其中$setIntersection和$size操作符都被引入，那么您仍然可以这样做，但它只需要更长的处理数组的形式。

您主要需要 $unwind 数组并单独处理每个匹配:

        { "$match": {
            "android_id": { "$ne": user.android_id },
            "interests": { "$in": user.interests }
        }},
        { "$unwind": "$interests" },
        { "$group": {
            "_id": "$_id",
            "android_id": { "$first": "$android_id" },
            "interests": { "$push": "$interests" },
            "common": {
              "$sum": {
                "$add": [
                  { "$cond": [{ "$eq": [ "$interests", user.interests[0] ] },1,0 ] },
                  { "$cond": [{ "$eq": [ "$interests", user.interests[1] ] },1,0 ] },
                  { "$cond": [{ "$eq": [ "$interests", user.interests[2] ] },1,0 ] }
                ]
              }
            }
        }},
        { "$sort": { "common": -1 }},
        { "$limit": 5 }

在管道中生成条件匹配更实际:

    var pipeline = [
        { "$match": {
            "android_id": { "$ne": user.android_id },
            "interests": { "$in": user.interests }
        }},
        { "$unwind": "$interests" }
    ];
    var group = 
        { "$group": {
            "_id": "$_id",
            "android_id": { "$first": "$android_id" },
            "interests": { "$push": "$interests" },
            "common": {
              "$sum": {
                "$add": []
              }
            }
        }};
    user.interests.forEach(function(interest) {
      group.$group.common.$sum.$add.push(
        { "$cond": [{ "$eq": [ "$interests", interest ] }, 1, 0 ] }
      );
    });
    pipeline.push(group);
    pipeline = pipeline.concat([
        { "$sort": { "common": -1 }},
        { "$limit": 5 }
    ])
    User.aggregate(pipeline,function(err,result) {
    });

这里的关键元素是当前用户和被检查用户的"兴趣"被分离出来进行比较，看看他们是否"相等"。 $cond 的结果为1(为真)或0(为假)。

任何返回(每对最多只能是1)都被传递给 $sum 累加器，该累加器计算共同匹配。您可以将 $match 与$in条件交替使用:

        { "$unwind": "$interests" },
        { "$match": { "interests": { "$in": user.interests } },
        { "$group": {
            "_id": "$_id",
            "android_id": { "$first": "$android_id" },
            "common": { "$sum": 1 }
        }}

但是这自然会破坏数组内容，因为不匹配的内容会被过滤掉。因此，这取决于您希望在响应中使用什么。

这是获得"公共"计数的基本过程，用于进一步处理，如$sort和$limit，以获得"top 5"。

只是为了好玩，下面是一个基本的node.js清单来显示常见匹配的效果:Var async = require('async')，Mongoose = require(' Mongoose ')，

mongoose.connect('mongodb://localhost/sample');
var interestSchema = new Schema({
  name: String
});
var userSchema = new Schema({
  name: String,
  interests: [{ type: Schema.Types.ObjectId, ref: 'Interest' }]
});
var Interest = mongoose.model( 'Interest', interestSchema );
var User = mongoose.model( 'User', userSchema );
var interestHash = {};
async.series(
  [
    function(callback) {
      async.each([Interest,User],function(model,callback) {
        model.remove({},callback);
      },callback);
    },
    function(callback) {
      async.each(
        [
          "Tennis",
          "Football",
          "Gaming",
          "Cooking",
          "Yoga"
        ],
        function(interest,callback) {
          Interest.create({ name: interest},function(err,obj) {
            if (err) callback(err);
            interestHash[obj.name] = obj._id;
            callback();
          });
        },
        callback
      );
    },
    function(callback) {
      async.each(
        [
          { name: "Bob", interests: ["Tennis","Football","Gaming"] },
          { name: "Tom", interests: ["Football","Cooking","Yoga"] },
          { name: "Sue", interests: ["Tennis","Gaming","Yoga","Cooking"] }
        ],
        function(data,callback) {
          data.interests = data.interests.map(function(interest) {
            return interestHash[interest];
          });
          User.create(data,function(err,user) {
            //console.log(user);
            callback(err);
          })
        },
        callback
      );
    },
    function(callback) {
      async.waterfall(
        [
          function(callback) {
            User.findOne({ name: "Bob" },callback);
          },
          function(user,callback) {
            console.log(user);
            User.aggregate(
              [
                { "$match": {
                  "_id": { "$ne": user._id },
                  "interests": { "$in": user.interests }
                }},
                { "$project": {
                  "name": 1,
                  "interests": 1,
                  "common": {
                    "$size": {
                      "$setIntersection": [ "$interests", user.interests ]
                    }
                  }
                }},
                { "$sort": { "common": -1 } }
              ],
              function(err,result) {
                if (err) callback(err);
                Interest.populate(result,'interests',function(err,result) {
                  console.log(result);
                  callback(err);
                });
              }
            );
          }
        ],
        callback
      );
    }
  ],
  function(err) {
    if (err) throw err;
    //console.dir(interestHash);
    mongoose.disconnect();
  }
);

将输出:

{ _id: 55dbd7be0e5516ac16ea62d1,
  name: 'Bob',
  __v: 0,
  interests:
   [ 55dbd7be0e5516ac16ea62cc,
     55dbd7be0e5516ac16ea62cd,
     55dbd7be0e5516ac16ea62ce ] }
[ { _id: 55dbd7be0e5516ac16ea62d3,
    name: 'Sue',
    interests:
     [ { _id: 55dbd7be0e5516ac16ea62cc, name: 'Tennis', __v: 0 },
       { _id: 55dbd7be0e5516ac16ea62ce, name: 'Gaming', __v: 0 },
       { _id: 55dbd7be0e5516ac16ea62d0, name: 'Yoga', __v: 0 },
       { _id: 55dbd7be0e5516ac16ea62cf, name: 'Cooking', __v: 0 } ],
    common: 2 },
  { _id: 55dbd7be0e5516ac16ea62d2,
    name: 'Tom',
    interests:
     [ { _id: 55dbd7be0e5516ac16ea62cd, name: 'Football', __v: 0 },
       { _id: 55dbd7be0e5516ac16ea62cf, name: 'Cooking', __v: 0 },
       { _id: 55dbd7be0e5516ac16ea62d0, name: 'Yoga', __v: 0 } ],
    common: 1 } ]