MongoDB将相关的集合项计数与其他集合结果合并

时间：2015-01-20 15:51:34

标签： node.js mongodb mongoose mongodb-query aggregation-framework

我是mongodb的新手，并试图找出如何有效地查询集合中的每个项目。

我有projects收集＆amp; tasks个收藏品

//projects
{
   _id: ObjectId(),
   name: String
}
//tasks
{
   _id: ObjectId(),
   projectId: ObjectId(), //reference project id
   completed: Bool
}

我想获得所有项目，然后计算每个项目的completed和incomplete任务

db.projects.find({})...
//perhaps something similar in output
[
 {
   _id: ObjectId(), //projectId
   name: String
   completed: Number,
   incomplete: Number
 }
]

我使用mongoose作为ORM。我不知道这是否可能在mongoose甚至是原生的mongodb查询中。感谢任何帮助。谢谢！

2 个答案:

答案 0 :(得分：3)

无论你如何看待这个，只要你有这样的规范化关系，那么你需要两个查询来获得包含“tasks”集合中细节的结果，并填写“projects”集合中的详细信息。 MongoDB不以任何方式使用连接，而且mongoose也不例外。 Mongoose确实提供了.populate()，但这只是本质上运行另一个查询并在引用的字段值上合并结果的便利魔法。

因此，这可能是您可能最终考虑将项目信息嵌入任务的一种情况。当然会有重复，但它使查询模式更简单，使用单一集合。

使用引用的模型保持集合分离，基本上你有两种方法。但首先，您可以使用aggregate来获得更符合实际要求的结果：

      Task.aggregate(
        [
          { "$group": {
            "_id": "$projectId",
            "completed": {
              "$sum": {
                "$cond": [ "$completed", 1, 0 ]
              }
            },
            "incomplete": {
              "$sum": {
                "$cond": [ "$completed", 0, 1 ]
              }
            }
          }}
        ],
        function(err,results) {

        }
    );

这仅仅使用$group管道，以便在“任务”集合中累积“projectid”的值。为了计算“已完成”和“不完整”的值，我们使用$cond运算符作为三元数来决定传递给$sum的值。由于此处的第一个或“if”条件是布尔值，因此现有的布尔“完整”字段将执行，将true传递给“then”或“else”传递第三个参数。

这些结果没问题，但它们不包含“project”集合中收集的“_id”值的任何信息。使输出看起来像这样的一种方法是从返回的“results”对象的聚合结果回调中调用.populate()的模型形式：

    Project.populate(results,{ "path": "_id" },callback);

在这种形式中，.populate()调用将对象或数据数组作为第一个参数，第二个是用于总体的选项文档，其中必需字段用于“路径”。这将处理任何项目并从称为将这些对象插入回调中的结果数据的模型中“填充”。

作为完整的示例列表：

var async = require('async'),
    mongoose = require('mongoose'),
    Schema = mongoose.Schema;

var projectSchema = new Schema({
  "name": String
});

var taskSchema = new Schema({
  "projectId": { "type": Schema.Types.ObjectId, "ref": "Project" },
  "completed": { "type": Boolean, "default": false }
});

var Project = mongoose.model( "Project", projectSchema );
var Task = mongoose.model( "Task", taskSchema );

mongoose.connect('mongodb://localhost/test');

async.waterfall(
  [
    function(callback) {
      async.each([Project,Task],function(model,callback) {
        model.remove({},callback);
      },
      function(err) {
        callback(err);
      });
    },

    function(callback) {
      Project.create({ "name": "Project1" },callback);
    },

    function(project,callback) {
      Project.create({ "name": "Project2" },callback);
    },

    function(project,callback) {
      Task.create({ "projectId": project },callback);
    },

    function(task,callback) {
      Task.aggregate(
        [
          { "$group": {
            "_id": "$projectId",
            "completed": {
              "$sum": {
                "$cond": [ "$completed", 1, 0 ]
              }
            },
            "incomplete": {
              "$sum": {
                "$cond": [ "$completed", 0, 1 ]
              }
            }
          }}
        ],
        function(err,results) {
          if (err) callback(err);
          Project.populate(results,{ "path": "_id" },callback);
        }
      );
    }
  ],
  function(err,results) {
    if (err) throw err;
    console.log( JSON.stringify( results, undefined, 4 ));
    process.exit();
  }
);

这会产生如下结果：

[
    {
        "_id": {
            "_id": "54beef3178ef08ca249b98ef",
            "name": "Project2",
            "__v": 0
        },
        "completed": 0,
        "incomplete": 1
    }
]

所以.populate()适用于这种聚合结果，即使是另一种查询，也应该适用于大多数目的。然而，在列表中包含了一个特定的例子，其中创建了“两个”项目，但当然只有“一个”任务只引用其中一个项目。

由于聚合正在处理“任务”集合，因此它不知道任何未在那里引用的“项目”。为了获得计算总数的“项目”的完整列表，您需要更具体地运行两个查询并“合并”结果。

这基本上是对不同键和数据的“哈希合并”，但是对此的好帮手是一个名为nedb的模块，它允许您以与MongoDB查询和操作更一致的方式应用逻辑。

基本上，您需要具有扩充字段的“projects”集合中的数据副本，然后您希望将该信息与聚合结果“合并”或.update()。再次作为完整列表来演示：

var async = require('async'),
    mongoose = require('mongoose'),
    Schema = mongoose.Schema,
    DataStore = require('nedb'),
    db = new DataStore();


var projectSchema = new Schema({
  "name": String
});

var taskSchema = new Schema({
  "projectId": { "type": Schema.Types.ObjectId, "ref": "Project" },
  "completed": { "type": Boolean, "default": false }
});

var Project = mongoose.model( "Project", projectSchema );
var Task = mongoose.model( "Task", taskSchema );

mongoose.connect('mongodb://localhost/test');

async.waterfall(
  [
    function(callback) {
      async.each([Project,Task],function(model,callback) {
        model.remove({},callback);
      },
      function(err) {
        callback(err);
      });
    },

    function(callback) {
      Project.create({ "name": "Project1" },callback);
    },

    function(project,callback) {
      Project.create({ "name": "Project2" },callback);
    },

    function(project,callback) {
      Task.create({ "projectId": project },callback);
    },

    function(task,callback) {
      async.series(
        [

          function(callback) {
            Project.find({},function(err,projects) {
              async.eachLimit(projects,10,function(project,callback) {
                db.insert({
                  "projectId": project._id.toString(),
                  "name": project.name,
                  "completed": 0,
                  "incomplete": 0
                },callback);
              },callback);
            });
          },

          function(callback) {
            Task.aggregate(
              [
                { "$group": {
                  "_id": "$projectId",
                  "completed": {
                    "$sum": {
                      "$cond": [ "$completed", 1, 0 ]
                    }
                  },
                  "incomplete": {
                    "$sum": {
                      "$cond": [ "$completed", 0, 1 ]
                    }
                  }
                }}
              ],
              function(err,results) {
                async.eachLimit(results,10,function(result,callback) {
                  db.update(
                    { "projectId": result._id.toString() },
                    { "$set": {
                        "complete": result.complete,
                        "incomplete": result.incomplete
                      }
                    },
                    callback
                  );
                },callback);
              }
            );
          },

        ],

        function(err) {
          if (err) callback(err);
          db.find({},{ "_id": 0 },callback);
        }
      );
    }
  ],
  function(err,results) {
    if (err) throw err;
    console.log( JSON.stringify( results, undefined, 4 ));
    process.exit();
  }

结果在这里：

[
    {
        "projectId": "54beef4c23d4e4e0246379db",
        "name": "Project2",
        "completed": 0,
        "incomplete": 1
    },
    {
        "projectId": "54beef4c23d4e4e0246379da",
        "name": "Project1",
        "completed": 0,
        "incomplete": 0
    }
]

列出来自每个“项目”的数据，并包含与“任务”集合相关的计算值。

因此，您可以采取一些方法。同样，最好只将“任务”嵌入到“项目”项目中，这也是一种简单的聚合方法。如果你要嵌入任务信息，那么你也可以在“项目”对象上维护“完整”和“不完整”的计数器，并简单地更新这些计数器，因为在{{3运营商。

var taskSchema = new Schema({
  "completed": { "type": Boolean, "default": false }
});

var projectSchema = new Schema({
  "name": String,
  "completed": { "type": Number, "default": 0 },
  "incomplete": { "type": Number, "default": 0 }
  "tasks": [taskSchema]
});

var Project = mongoose.model( "Project", projectSchema );
// cheat for a model object with no collection
var Task = mongoose.model( "Task", taskSchema, undefined );

// Then in later code

// Adding a task
var task = new Task();
Project.update(
    { "task._id": { "$ne": task._id } },
    { 
        "$push": { "tasks": task },
        "$inc": {
            "completed": ( task.completed ) ? 1 : 0,
            "incomplete": ( !task.completed ) ? 1 : 0;
        }
    },
    callback
 );

// Removing a task
Project.update(
    { "task._id": task._id },
    { 
        "$pull": { "tasks": { "_id": task._id } },
        "$inc": {
            "completed": ( task.completed ) ? -1 : 0,
            "incomplete": ( !task.completed ) ? -1 : 0;
        }
    },
    callback
 );


 // Marking complete
Project.update(
    { "tasks": { "$elemMatch": { "_id": task._id, "completed": false } }},
    { 
        "$set": { "tasks.$.completed": true },
        "$inc": {
            "completed": 1,
            "incomplete": -1
        }
    },
    callback
);

您必须知道当前任务状态，但计数器更新才能正常工作，但这很容易编码，您可能至少应该在传递给方法的对象中包含这些详细信息。

就个人而言，我会重新模仿后一种形式并做到这一点。你可以在这里查看两个例子中的“合并”查询，但这当然是有代价的。

答案 1 :(得分：0)

当您需要对MongoDB中的内容进行分组或计数时，您通常需要使用aggregation framework。以下是如何计算shell中的数据：

db.tasks.aggregate([ {$group: {
  _id: {projectID: "$projectID", completed: "$completed"},
  count: {$sum: 1}
  }});

这将为项目中的每个任务返回两个文档 - 一个包含已完成任务的计数，另一个包含尚未完成的任务。

我从未使用过Mongoose，但现在你可以从中开始：）

相关问题
最新问题