Come funziona l'aggregazione di gruppo in MongoDB?
L'operatore $group deve essere utilizzato per raggruppare i documenti di input in base all'espressione _id specificata. Dovrebbe quindi restituire un singolo documento con i valori totali per ciascun gruppo separato. Per iniziare con l'implementazione, abbiamo creato la raccolta 'Libri' in MongoDB. Dopo la creazione della collezione “Libri”, abbiamo inserito i documenti che sono associati ai diversi campi. I documenti vengono inseriti nella collection tramite il metodo insertMany() in quanto la query da eseguire è mostrata di seguito.
>db.Books.insertMany([{
_id:1,
titolo: 'Anna Karenina',
prezzo: 290,
anno: 1879,
order_status: 'Disponibile',
autore: {
'nome':'Leone Tolstoj'
}
},
{
_id:2,
titolo: 'Uccidere un Mockingbird',
prezzo: 500,
anno: 1960,
order_status: 'esaurito',
autore: {
'nome': 'Harper Lee'
}
},
{
_id:3,
titolo: 'L'uomo invisibile',
prezzo: 312,
anno: 1953,
order_status: 'Disponibile',
autore: {
'nome': 'Ralph Ellison'
}
},
{
_id:4,
titolo: 'Amato',
prezzo: 370,
anno: 1873,
order_status: 'esaurito',
autore: {
'nome':'Toni Morrison'
}
},
{
_id:5,
titolo: 'Le cose cadono a pezzi',
prezzo: 200,
anno: 1958,
order_status: 'Disponibile',
autore: {
'name':'Chinua Achebe'
}
},
{
_id:6,
titolo: 'Il colore viola',
prezzo: 510,
anno: 1982,
order_status: 'esaurito',
autore: {
'nome':'Alice Walker'
}
}
])
I documenti vengono archiviati correttamente nella raccolta 'Libri' senza riscontrare alcun errore perché l'output viene riconosciuto come 'vero'. Ora utilizzeremo questi documenti della raccolta 'Libri' per eseguire l'aggregazione '$gruppo'.
Esempio n. 1: utilizzo di $group Aggregation
Il semplice utilizzo dell'aggregazione $group è dimostrato qui. La query aggregata inserisce prima l'operatore '$group', quindi l'operatore '$group' prende ulteriormente le espressioni per generare i documenti raggruppati.
>db.Libri.aggregato([
{ $gruppo:{ _id:'$nome.autore'} }
])
La query sopra dell'operatore $group è specificata con il campo '_id' per calcolare i valori totali per tutti i documenti di input. Quindi, il campo '_id' viene allocato con '$author.name' che forma un gruppo diverso nel campo '_id'. Verranno restituiti i valori separati di $author.name perché non calcoliamo alcun valore accumulato. L'esecuzione della query di aggregazione $group ha il seguente output. Il campo _id contiene valori di author.names.
Esempio n. 2: utilizzo di $group Aggregation con $push Accumulator
L'esempio di aggregazione $group utilizza qualsiasi accumulatore già menzionato sopra. Ma possiamo usare gli accumulatori nell'aggregazione $group. Gli operatori dell'accumulatore sono quelli utilizzati sui campi del documento di input diversi da quelli che sono “raggruppati” sotto “_id”. Supponiamo di voler inserire i campi dell'espressione in un array, quindi l'accumulatore '$push' viene richiamato nell'operatore '$group'. L'esempio ti aiuterà a capire più chiaramente l'accumulatore '$push' del '$group'.
>db.Libri.aggregato([
{ $gruppo : { _id : '$_id', anno: { $push: '$anno' } } }
]
).bello();
Qui, vogliamo raggruppare la data dell'anno di pubblicazione dei libri specificati nell'array. La query precedente dovrebbe essere applicata per ottenere questo risultato. La query di aggregazione viene fornita con l'espressione in cui l'operatore '$group' prende l'espressione del campo '_id' e l'espressione del campo 'year' per ottenere l'anno del gruppo utilizzando l'accumulatore $push. L'output recuperato da questa query specifica crea l'array di campi dell'anno e memorizza al suo interno il documento raggruppato restituito.
Esempio n. 3: utilizzo di $group Aggregation con l'accumulatore '$min'.
Successivamente, abbiamo l'accumulatore '$min' che viene utilizzato nell'aggregazione $group per ottenere il valore minimo corrispondente da ogni documento nella raccolta. Di seguito viene fornita l'espressione di query per l'accumulatore $min.
>db.Libri.aggregato([{
$gruppo:{
_id:{
titolo: '$titolo',
stato_ordine: '$stato_ordine'
},
minPrezzo:{$min: '$prezzo'}
}
}
])
La query ha l'espressione di aggregazione “$group” dove abbiamo raggruppato il documento per i campi “title” e “order_status”. Quindi, abbiamo fornito l'accumulatore $min che ha raggruppato i documenti ottenendo i valori del prezzo minimo dai campi non raggruppati. Quando eseguiamo questa query di accumulatore $min di seguito, restituisce i documenti raggruppati per titolo e order_status in una sequenza. Il prezzo minimo appare per primo e il prezzo più alto del documento viene posizionato per ultimo.
Esempio n. 4: utilizzare $group Aggregation con $sum Accumulator
Per ottenere la somma di tutti i campi numerici utilizzando l'operatore $group, viene distribuita l'operazione $sum accumulator. I valori non numerici nelle collezioni sono considerati da questo accumulatore. Inoltre, qui stiamo usando l'aggregazione $match con l'aggregazione $group. L'aggregazione $match accetta le condizioni di query specificate in un documento e passa il documento corrispondente all'aggregazione $group che quindi restituisce la somma del documento per ciascun gruppo. Per l'accumulatore $sum, la query è presentata di seguito.
>db.Libri.aggregato([{ $match:{ order_status:'Disponibile'}},
{ $group:{ _id:'$author.name', totalBooks: { $sum:1 } }
}])
La precedente query di aggregazione inizia con l'operatore $match che corrisponde a tutti gli 'order_status' il cui stato è 'In-Stock' e passato al $group come input. Quindi, l'operatore $group ha l'espressione accumulatore $sum che restituisce la somma di tutti i libri nello stock. Si noti che '$sum:1' aggiunge 1 a ogni documento che appartiene allo stesso gruppo. L'output qui mostrava solo due documenti raggruppati che hanno 'order_status' associato a 'In-Stock'.
Esempio n. 5: utilizzare $group Aggregation con $sort Aggregation
L'operatore $group qui viene utilizzato con l'operatore '$sort' che viene utilizzato per ordinare i documenti raggruppati. La query seguente prevede tre passaggi per l'operazione di ordinamento. La prima è la fase $match, poi la fase $group, e l'ultima è la fase $sort che ordina il documento raggruppato.
>db.Libri.aggregato([{ $match:{ order_status:'esaurito'}},
{ $group:{ _id:{ authorName :'$author.name'}, totalBooks: { $sum:1} } },
{ $ordina:{ nomeautore:1}}
])
Qui, abbiamo recuperato il documento corrispondente il cui 'order_status' è esaurito. Quindi, il documento abbinato viene inserito nella fase a gironi $ che ha raggruppato il documento con il campo 'authorName' e il 'totalBooks'. L'espressione $group è associata all'accumulatore $sum al numero totale di libri 'esauriti'. I documenti raggruppati vengono quindi ordinati con l'espressione $sort in ordine crescente poiché '1' qui indica l'ordine crescente. Il documento di gruppo ordinato nell'ordine specificato viene ottenuto nell'output seguente.
Esempio n. 6: utilizzare l'aggregazione $group per il valore distinto
La procedura di aggregazione raggruppa anche i documenti per elemento utilizzando l'operatore $group per estrarre i valori distinti degli elementi. Diamo l'espressione di query di questa istruzione in MongoDB.
>db.Books.aggregate( [ { $group : { _id : '$title' } } ] ).pretty();La query di aggregazione viene applicata alla raccolta Books per ottenere il valore distinto del documento di gruppo. Il $group qui prende l'espressione _id che emette i valori distinti come abbiamo inserito il campo 'titolo'. L'output del documento di gruppo viene ottenuto eseguendo questa query che ha il gruppo di nomi di titolo rispetto al campo _id.
Conclusione
La guida mirava a chiarire il concetto dell'operatore di aggregazione $group per raggruppare il documento nel database MongoDB. L'approccio aggregato di MongoDB migliora i fenomeni di raggruppamento. La struttura della sintassi dell'operatore $group è illustrata con i programmi di esempio. Oltre all'esempio di base degli operatori $group, abbiamo utilizzato questo operatore anche con alcuni accumulatori come $push, $min, $sum e operatori come $match e $sort.