A consulta para contar as ocorrências "únicas" em um
"EndpointId" de cada um dos "Uid" em "Tags" e o "Type" em "Sensors" seria: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" }
}}
])
Ou para 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)
}
);
Quais saídas:
{
"EndpointId" : "89799bcc-e86f-4c8a-b340-8b5ed53caf83",
"tagCount" : 4,
"sensorCount" : 16
}
Embora na verdade seja a maneira "mais eficiente" de fazer isso, considerando que os documentos apresentados têm valores únicos para
"Uid" de qualquer forma seria $reduce os valores dentro dos próprios documentos: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" ] }
}
}
}
}
}
}
}
}}
])
No entanto, a instrução não mapeia bem para LINQ, portanto, seria necessário usar o
BsonDocument interface para construir o BSON para a instrução. E, claro, onde o mesmo "Uid" os valores "fizeram" de fato ocorrerem em vários documentos na coleção, então o $unwind as instruções são necessárias para "agrupá-las" em documentos de dentro das entradas da matriz. Original
Você resolve isso obtendo o
$size
das matrizes. Para a matriz externa, isso é simplesmente aplicado ao caminho do campo da matriz no documento e, para os itens da matriz interna, você precisa processar com $map
para processar cada "Tags" elemento e, em seguida, obtenha o $size
de "Sensors" e $sum
a matriz resultante para reduzir à contagem geral. Por documento que seria:
db.collection.aggregate([
{ "$project": {
"tags": { "$size": "$Tags" },
"sensors": {
"$sum": {
"$map": {
"input": "$Tags",
"in": { "$size": "$$this.Sensors" }
}
}
}
}}
])
Qual onde você atribuiu a classes em seu código C# seria como:
collection.AsQueryable()
.Select(p => new
{
tags = p.Tags.Count(),
sensors = p.Tags.Select(x => x.Sensors.Count()).Sum()
}
);
Onde esses retornam:
{ "tags" : 3, "sensors" : 13 }
{ "tags" : 2, "sensors" : 8 }
Onde você deseja
$group
os resultados, como por exemplo em toda a coleção, então você faria: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" }
}
}
}
}
}}
])
Qual para o seu código C # como antes seria:
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())
}
);
Onde esses retornam:
{ "tags" : 5, "sensors" : 21 }
E para
"EndpointId , então você simplesmente usa esse campo como a chave de agrupamento, em vez do null ou 0 conforme é aplicado pelo mapeamento do driver 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())
}
);
Que é, obviamente, a mesma soma da amostra de dois documentos que você nos deu:
{ "tags" : 5, "sensors" : 21 }
Portanto, esses são resultados muito simples, com execução de pipeline simples assim que você se acostumar com a sintaxe.
Sugiro familiarizar-se com os Operadores de agregação da documentação principal e, claro, do "Folha de dicas do LINQ" de expressões e seu mapeamento de uso de dentro do repositório de código do driver C#.
Consulte também a Referência LINQ geral na referência do driver C# para outros exemplos de como isso é mapeado para o Aggregation Framework do MongoDB em geral.
