Personalmente non sono un grande fan della trasformazione dei "dati" come i nomi delle chiavi in un risultato. I principi del framework di aggregazione tendono a concordare poiché nemmeno questo tipo di operazione è supportata.
Quindi la preferenza personale è mantenere i "dati" come "dati" e accettare che l'output elaborato sia effettivamente migliore e più logico per una progettazione di oggetti coerente:
db.people.aggregate([
{ "$group": {
"_id": "$sex",
"hobbies": { "$push": "$hobbies" },
"total": { "$sum": 1 }
}},
{ "$unwind": "$hobbies" },
{ "$unwind": "$hobbies" },
{ "$group": {
"_id": {
"sex": "$_id",
"hobby": "$hobbies"
},
"total": { "$first": "$total" },
"hobbyCount": { "$sum": 1 }
}},
{ "$group": {
"_id": "$_id.sex",
"total": { "$first": "$total" },
"hobbies": {
"$push": { "name": "$_id.hobby", "count": "$hobbyCount" }
}
}}
])
Che produce un risultato come questo:
[
{
"_id" : "female",
"total" : 1,
"hobbies" : [
{
"name" : "tennis",
"count" : 1
},
{
"name" : "football",
"count" : 1
}
]
},
{
"_id" : "male",
"total" : 2,
"hobbies" : [
{
"name" : "swimming",
"count" : 1
},
{
"name" : "tennis",
"count" : 2
},
{
"name" : "football",
"count" : 2
}
]
}
]
Quindi l'iniziale $group fa il conteggio per "sesso" e accumula gli hobby in una serie di array. Quindi per denormalizzarti $unwind due volte per ottenere elementi singolari, $group per ottenere i totali per hobby sotto ogni sesso e infine raggruppare una matrice per ogni sesso solo.
Sono gli stessi dati, ha una struttura organica e coerente che è facile da elaborare e MongoDB e il framework di aggregazione sono stati abbastanza felici di produrre questo output.
Se devi davvero convertire i tuoi dati in nomi di chiavi (e ti consiglio comunque di non farlo perché non è un buon modello da seguire nella progettazione), eseguire una tale trasformazione dallo stato finale è abbastanza banale per l'elaborazione del codice client. Come esempio JavaScript di base adatto per la shell:
var out = db.people.aggregate([
{ "$group": {
"_id": "$sex",
"hobbies": { "$push": "$hobbies" },
"total": { "$sum": 1 }
}},
{ "$unwind": "$hobbies" },
{ "$unwind": "$hobbies" },
{ "$group": {
"_id": {
"sex": "$_id",
"hobby": "$hobbies"
},
"total": { "$first": "$total" },
"hobbyCount": { "$sum": 1 }
}},
{ "$group": {
"_id": "$_id.sex",
"total": { "$first": "$total" },
"hobbies": {
"$push": { "name": "$_id.hobby", "count": "$hobbyCount" }
}
}}
]).toArray();
out.forEach(function(doc) {
var obj = {};
doc.hobbies.sort(function(a,b) { return a.count < b.count });
doc.hobbies.forEach(function(hobby) {
obj[hobby.name] = hobby.count;
});
doc.hobbies = obj;
printjson(doc);
});
E quindi stai sostanzialmente elaborando ogni risultato del cursore nel modulo di output desiderato, che in realtà non è una funzione di aggregazione davvero richiesta sul server:
{
"_id" : "female",
"total" : 1,
"hobbies" : {
"tennis" : 1,
"football" : 1
}
}
{
"_id" : "male",
"total" : 2,
"hobbies" : {
"tennis" : 2,
"football" : 2,
"swimming" : 1
}
}
Dove dovrebbe anche essere abbastanza banale implementare quel tipo di manipolazione nell'elaborazione del flusso del risultato del cursore da trasformare come richiesto, poiché è fondamentalmente solo la stessa logica.
D'altra parte, puoi sempre implementare tutte le manipolazioni sul server usando invece mapReduce:
db.people.mapReduce(
function() {
emit(
this.sex,
{
"total": 1,
"hobbies": this.hobbies.map(function(key) {
return { "name": key, "count": 1 };
})
}
);
},
function(key,values) {
var obj = {},
reduced = {
"total": 0,
"hobbies": []
};
values.forEach(function(value) {
reduced.total += value.total;
value.hobbies.forEach(function(hobby) {
if ( !obj.hasOwnProperty(hobby.name) )
obj[hobby.name] = 0;
obj[hobby.name] += hobby.count;
});
});
reduced.hobbies = Object.keys(obj).map(function(key) {
return { "name": key, "count": obj[key] };
}).sort(function(a,b) {
return a.count < b.count;
});
return reduced;
},
{
"out": { "inline": 1 },
"finalize": function(key,value) {
var obj = {};
value.hobbies.forEach(function(hobby) {
obj[hobby.name] = hobby.count;
});
value.hobbies = obj;
return value;
}
}
)
Dove mapReduce ha il suo stile distinto di output, ma gli stessi principi sono usati nell'accumulazione e nella manipolazione, se non efficiente quanto il framework di aggregazione può fare:
"results" : [
{
"_id" : "female",
"value" : {
"total" : 1,
"hobbies" : {
"football" : 1,
"tennis" : 1
}
}
},
{
"_id" : "male",
"value" : {
"total" : 2,
"hobbies" : {
"football" : 2,
"tennis" : 2,
"swimming" : 1
}
}
}
]
Alla fine, continuo a dire che la prima forma di elaborazione è la più efficiente e fornisce alla mia mente il funzionamento più naturale e coerente dell'output dei dati, senza nemmeno tentare di convertire i punti dati nei nomi delle chiavi. Probabilmente è meglio considerare di seguire questo schema, ma se proprio devi, allora ci sono modi per manipolare i risultati in una forma desiderata in vari approcci all'elaborazione.
