Запрос на подсчет "уникальных" вхождений в "EndpointId" каждого из "Uid" в "Tags" и "Type" в "Sensors" будет:
db.collection.aggregate([
{ "$unwind": "$Tags" },
{ "$unwind": "$Tags.Sensors" },
{ "$group": {
"_id": {
"EndpointId": "$EndpointId",
"Uid": "$Tags.Uid",
"Type": "$Tags.Sensors.Type"
},
}},
{ "$group": {
"_id": {
"EndpointId": "$_id.EndpointId",
"Uid": "$_id.Uid",
},
"count": { "$sum": 1 }
}},
{ "$group": {
"_id": "$_id.EndpointId",
"tagCount": { "$sum": 1 },
"sensorCount": { "$sum": "$count" }
}}
])
или для C #
var results = collection.AsQueryable()
.SelectMany(p => p.Tags, (p, tag) => new
{
EndpointId = p.EndpointId,
Uid = tag.Uid,
Sensors = tag.Sensors
}
)
.SelectMany(p => p.Sensors, (p, sensor) => new
{
EndpointId = p.EndpointId,
Uid = p.Uid,
Type = sensor.Type
}
)
.GroupBy(p => new { EndpointId = p.EndpointId, Uid = p.Uid, Type = p.Type })
.GroupBy(p => new { EndpointId = p.Key.EndpointId, Uid = p.Key.Uid },
(k, s) => new { Key = k, count = s.Count() }
)
.GroupBy(p => p.Key.EndpointId,
(k, s) => new
{
EndpointId = k,
tagCount = s.Count(),
sensorCount = s.Sum(x => x.count)
}
);
Какие выходы:
{
"EndpointId" : "89799bcc-e86f-4c8a-b340-8b5ed53caf83",
"tagCount" : 4,
"sensorCount" : 16
}
Хотя на самом деле «наиболее эффективный» способ сделать это, учитывая, что представленные документы имеют уникальные значения для "Uid", все равно будет $reduce суммы в самих документах:
db.collection.aggregate([
{ "$group": {
"_id": "$EndpointId",
"tags": {
"$sum": {
"$size": { "$setUnion": ["$Tags.Uid",[]] }
}
},
"sensors": {
"$sum": {
"$sum": {
"$map": {
"input": { "$setUnion": ["$Tags.Uid",[]] },
"as": "tag",
"in": {
"$size": {
"$reduce": {
"input": {
"$filter": {
"input": {
"$map": {
"input": "$Tags",
"in": {
"Uid": "$$this.Uid",
"Type": "$$this.Sensors.Type"
}
}
},
"cond": { "$eq": [ "$$this.Uid", "$$tag" ] }
}
},
"initialValue": [],
"in": { "$setUnion": [ "$$value", "$$this.Type" ] }
}
}
}
}
}
}
}
}}
])
Однако оператор не очень хорошо отображается на LINQ, поэтому вам потребуется использовать интерфейс BsonDocument для построения BSON для этого оператора. И, конечно, если одни и те же значения "Uid" «действительно» встречаются в нескольких документах в коллекции, то операторы $unwind необходимы для того, чтобы «сгруппировать» их вместе по документам из записей массива.
Оригинал
Вы решаете эту проблему, получая $size массивов. Для внешнего массива это просто применяется к пути поля массива в документе, а для внутренних элементов массива вам нужно обработать с $map, чтобы обработать каждый элемент "Tags" и затем получить $size из "Sensors" и $sum результирующего массива для уменьшения до общего количества.
За документ, который будет:
db.collection.aggregate([
{ "$project": {
"tags": { "$size": "$Tags" },
"sensors": {
"$sum": {
"$map": {
"input": "$Tags",
"in": { "$size": "$$this.Sensors" }
}
}
}
}}
])
Что бы вы указали классам в вашем коде на C #:
collection.AsQueryable()
.Select(p => new
{
tags = p.Tags.Count(),
sensors = p.Tags.Select(x => x.Sensors.Count()).Sum()
}
);
Куда возвращаются те:
{ "tags" : 3, "sensors" : 13 }
{ "tags" : 2, "sensors" : 8 }
Если вы хотите $group результатов, как, например, для всей коллекции, вы должны сделать:
db.collection.aggregate([
/* The shell would use $match for "query" conditions */
//{ "$match": { "EndpointId": "89799bcc-e86f-4c8a-b340-8b5ed53caf83" } },
{ "$group": {
"_id": null,
"tags": { "$sum": { "$size": "$Tags" } },
"sensors": {
"$sum": {
"$sum": {
"$map": {
"input": "$Tags",
"in": { "$size": "$$this.Sensors" }
}
}
}
}
}}
])
Что для вашего кода C #, как и раньше, будет:
collection.AsQueryable()
.GroupBy(p => "", (k,s) => new
{
tags = s.Sum(p => p.Tags.Count()),
sensors = s.Sum(p => p.Tags.Select(x => x.Sensors.Count()).Sum())
}
);
Куда возвращаются те:
{ "tags" : 5, "sensors" : 21 }
А для "EndpointId вы просто используете это поле в качестве ключа группировки, а не null или 0, как оно применяется в отображении драйвера C #:
collection.AsQueryable()
/* Use the Where if you want a query to match only those documents */
//.Where(p => p.EndpointId == "89799bcc-e86f-4c8a-b340-8b5ed53caf83")
.GroupBy(p => p.EndpointId, (k,s) => new
{
tags = s.Sum(p => p.Tags.Count()),
sensors = s.Sum(p => p.Tags.Select(x => x.Sensors.Count()).Sum())
}
);
Это, конечно, та же сумма двух образцов документов, которые вы нам дали:
{ "tags" : 5, "sensors" : 21 }
Так что это очень простые результаты с простым конвейерным выполнением, когда вы привыкнете к синтаксису.
Я предлагаю ознакомиться с операторами агрегации из базовой документации и, конечно, "Шпаргалом LINQ" выражений и отображением их использования из хранилища кода драйвера C # .
Также см. Общую ссылку LINQ в справочнике по драйверам C # для других примеров того, как это отображается в Aggregation Framework MongoDB в целом.