如何同时等待I / O完成端口和事件？(How can I wait on an I/O completion port and an event at the same time?)

 当你看到这个过程并不是那么困难。 聚合“管道”就是这样，每个“阶段”将结果输入下一个进行处理。 就像unix“管道”： 
 
ps -ef | grep mongo | tee out.txt
 
 所以它只是添加阶段，实际上是三个$group阶段，其中第一阶段进行基本聚合，剩下的两阶段简单地“汇总”输出中所需的数组。 
 
db.collection.aggregate([
    { "$group": {
        "_id": {
            "bookId": "$bookId",
            "store": "$store",
            "shelf": "$shelf"
        },
        "count": { "$sum": 1 }
    }},
    { "$group": {
        "_id": {
            "bookId": "$_id.bookId",
            "store": "$_id.store"
        },
        "shelves": { 
            "$push": {
                "name": "$_id.shelf",
                "count": "$count"
            }
        }
    }},
    { "$group": {
        "_id": "$_id.bookId",
        "stores": {
            "$push": {
                "name": "$_id.store",
                "shelves": "$shelves"
            }
        }
    }}
])
 
 最后你可以$project将_id更改为bookId ，但你应该已经知道它是什么，并习惯将_id作为主键处理。 这样的操作需要付出代价，因此这是一种习惯，你不应该从一开始就学会正确地做事。 
 
 所以这里真正发生的是，构成分组细节的所有字段都成为$group的主键，而另一个字段被生成为count ，以计算该分组中的货架。 认为SQL等价： 
 
GROUP BY bookId, store, shelf
 
 所有其他阶段都将每个分组级别转换为数组条目，首先是商店内的货架，然后是bookId中的商店。 每次主要分组键中的字段由进入生成的数组的内容减少。 
 
 当你开始考虑“管道”处理时，它就变得清晰了。 在构造一个表单时，然后获取该输出并将其移动到下一个表单，依此类推。 这基本上就是如何在两个数组中折叠结果。 

The process isn't really that difficult when you look at at. The aggregation "pipeline" is exactly that, where each "stage" feeds a result into the next for processing. Just like unix "pipe":
 
ps -ef | grep mongo | tee out.txt
 
So it's just adding stages, and in fact three $group stages where the first does the basic aggregation and the remaining two simply "roll up" the arrays required in the output.
 
db.collection.aggregate([
    { "$group": {
        "_id": {
            "bookId": "$bookId",
            "store": "$store",
            "shelf": "$shelf"
        },
        "count": { "$sum": 1 }
    }},
    { "$group": {
        "_id": {
            "bookId": "$_id.bookId",
            "store": "$_id.store"
        },
        "shelves": { 
            "$push": {
                "name": "$_id.shelf",
                "count": "$count"
            }
        }
    }},
    { "$group": {
        "_id": "$_id.bookId",
        "stores": {
            "$push": {
                "name": "$_id.store",
                "shelves": "$shelves"
            }
        }
    }}
])
 
You could possibly $project at the end to change the _id to bookId, but you should already know that is what it is and get used to treating _id as a primary key. There is a cost to such operations, so it is a habit you should not get into and learn doing things correctly from the start.
 
So all that really happens here is all the fields that would make up the grouping detail are made the primary key of $group with the other field being produced as count, to count the shelves within that grouping. Think the SQL equivalent:
 
GROUP BY bookId, store, shelf
 
All each other stage does is transpose each grouping level into array entries, first by shelf within the store and then the store within the bookId. Each time the fields in the primary grouping key are reduced down by the content going into the produced array.
 
When you start thinking in terms of "pipeline" processing, then it becomes clear. As you construct one form, then take that output and move it to the next form and so on. This is basically how you fold the results within two arrays.