Aggregazione del gruppo MongoDB
Come funziona l'aggregazione di gruppo in MongoDB?
L'operatore del gruppo $ 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 collezione "Libri" in MongoDB. Dopo la creazione della collezione "libri", abbiamo inserito i documenti associati ai diversi campi. I documenti sono inseriti nella raccolta tramite il metodo InsertMany () poiché la query da eseguire è mostrata di seguito.
> db.Libri.InsertMany ([_id: 1,
Titolo: "Anna Karenina",
Prezzo: 290,
Anno: 1879,
Order_status: "in stock",
Autore:
"Nome": "Leo Tolstoy"
,
_id: 2,
Titolo: "Kill a Mockingbird",
Prezzo: 500,
Anno: 1960,
Order_status: "fuori stock",
Autore:
"Nome": "Harper Lee"
,
_id: 3,
Titolo: "Invisible Man",
Prezzo: 312,
Anno: 1953,
Order_status: "in stock",
Autore:
"Nome": "Ralph Ellison"
,
_id: 4,
Titolo: "Amato",
Prezzo: 370,
Anno: 1873,
order_status: "out_of_stock",
Autore:
"Nome": "Toni Morrison"
,
_id: 5,
Titolo: "Le cose cadono a pezzi",
Prezzo: 200,
Anno: 1958,
Order_status: "in stock",
Autore:
"Nome": "Chinua Achebe"
,
_id: 6,
Titolo: "The Color Purple",
Prezzo: 510,
Anno: 1982,
Order_status: "fuori stock",
Autore:
"Nome": "Alice Walker"
])
I documenti sono archiviati con successo nella raccolta di "libri" senza riscontrare alcun errore perché l'output è riconosciuto come "vero". Ora, useremo questi documenti della collezione "Libri" per eseguire l'aggregazione "$ Group".
Esempio n. 1: utilizzo dell'aggregazione del gruppo $
Il semplice utilizzo dell'aggregazione del gruppo $ è dimostrato qui. La query aggregata inserisce prima l'operatore "$ gruppo", quindi l'operatore "$ gruppo" prende inoltre le espressioni per generare i documenti raggruppati.
> db.Libri.aggregato([$ gruppo: _id: '$ autore.nome'
])
La query sopra dell'operatore del gruppo $ è specificata con il campo "_id" per calcolare i valori totali per tutti i documenti di input. Quindi, il campo "_id" viene assegnato con l'autore "$.nome "che forma un gruppo diverso nel campo" _id ". I valori separati di $ autore.il nome verrà restituito perché non calcoliamo alcun valori accumulati. L'esecuzione della query aggregata del gruppo $ ha il seguente output. Il campo _id ha valori dell'autore.nomi.
Esempio n. 2: utilizzo dell'aggregazione del gruppo $ con l'accumulatore di $
L'esempio dell'aggregazione di $ Group utilizza qualsiasi accumulatore già menzionato sopra. Ma possiamo usare gli accumulatori nell'aggregazione del gruppo $. Gli operatori dell'accumulatore sono quelli utilizzati su campi di documento di input diversi da quelli che sono "raggruppati" in "_id". Supponiamo che vogliamo spingere i campi dell'espressione in un array, quindi l'accumulatore "$ push" viene chiamato nell'operatore "$ gruppo". L'esempio ti aiuterà a capire più chiaramente l'accumulatore "$ push" del "gruppo $".
> db.Libri.aggregato([
$ gruppo: _id: "$ _id", anno: $ push: "$ year"
"
).bello();
Qui, vogliamo raggruppare la data dell'anno pubblicato dei libri indicati nell'array. La query sopra dovrebbe essere applicata per raggiungere questo obiettivo. La query di aggregazione è fornita con l'espressione in cui l'operatore "$ gruppo" prende l'espressione del campo "_id" e l'espressione del campo "anno" per ottenere l'anno di gruppo utilizzando l'accumulatore $ push. L'output recuperato da questa specifica query crea l'array di campi dell'anno e memorizza il documento raggruppato restituito al suo interno.
Esempio n. 3: utilizzo dell'aggregazione del gruppo $ con l'accumulatore "$ min"
Successivamente, abbiamo l'accumulatore "$ min" che viene utilizzato nell'aggregazione del gruppo $ per ottenere il valore di corrispondenza minimo da ogni documento della raccolta. L'espressione della query per l'accumulatore $ min è riportata di seguito.
> db.Libri.aggregato([$ gruppo:
_id:
Titolo: "$ Titolo",
order_status: '$ order_status'
,
Minprice: $ min: '$ price'
])
La query ha l'espressione di aggregazione "$ gruppo" in cui abbiamo raggruppato il documento per i campi "Titolo" e "Order_Status". Quindi, abbiamo fornito l'accumulatore $ min che ha raggruppato i documenti ottenendo i valori dei prezzi minimi dai campi non gruppi. Quando eseguiamo questa query di $ Min Accumulator di seguito, restituisce i documenti raggruppati per titolo e ordine_status in una sequenza. Il prezzo minimo appare per primo e il prezzo più alto del documento viene posto per ultimo.
Esempio n. 4: usa l'aggregazione del gruppo $ con l'accumulatore $ sum
Per ottenere la somma di tutti i campi numerici utilizzando l'operatore del gruppo $, l'operazione di accumulatore $ sum viene distribuita. I valori non numerici nelle raccolte sono considerati da questo accumulatore. Inoltre, stiamo usando l'aggregazione di $ Match qui con l'aggregazione del gruppo $. L'aggregazione di $ Match accetta le condizioni di query fornite in un documento e passa il documento abbinato all'aggregazione del gruppo $ che restituisce quindi la somma del documento per ciascun gruppo. Per l'accumulatore $ sum, la query è presentata di seguito.
> db.Libri.aggregato([$ match: order_status: 'in stock',
$ gruppo: _id: '$ autore.Nome ', Totalbooks: $ Sum: 1
])
La query di aggregazione sopra inizia con l'operatore $ match che corrisponde a tutti i "order_status" il cui stato è "in stock" e passa al gruppo $ come input. Quindi, l'operatore del gruppo $ ha l'espressione dell'accumulatore di $ sum che emette la somma di tutti i libri nel titolo. Si noti che "$ SUM: 1" aggiunge 1 a ciascun documento che appartiene allo stesso gruppo. L'output qui ha mostrato solo due documenti raggruppati che hanno "order_status" associato a "in stock".
Esempio n. 5: usa l'aggregazione del gruppo $ con l'aggregazione di $
L'operatore di $ Group qui viene utilizzato con l'operatore "$ ordin" che viene utilizzato per ordinare i documenti raggruppati. La seguente query ha tre passaggi per l'operazione di ordinamento. Prima è la fase di $ Match, quindi la fase di $ a due.
> db.Libri.aggregato([$ match: order_status: 'out of-stock',
$ GRUPPO: _ID: Authorname: '$ AUTOR.Nome ', Totalbooks: $ Sum: 1,
$ Ordine: Authorname: 1
])
Qui, abbiamo recuperato il documento abbinato il cui "order_status" è fuori stock. Quindi, il documento abbinato viene inserito nella fase a gironi $ che ha raggruppato il documento con il campo "Authorname" e "Totalbooks". L'espressione del gruppo $ è associata all'accumulatore di $ sum al numero totale di libri "fuori stock". I documenti raggruppati vengono quindi ordinati con l'espressione di $ Ording in ordine crescente poiché "1" qui indica l'ordine ascendente. Il documento di gruppo ordinato nell'ordine specificato è ottenuto nel seguente output.
Esempio # 6: usa l'aggregazione di $ Group per un valore distinto
La procedura di aggregazione raggruppa anche i documenti per articolo utilizzando l'operatore di $ gruppo per estrarre i valori degli articoli distinti. Facciamo l'espressione della query di questa affermazione in MongoDB.
> db.Libri.aggregate ([$ gruppo: _id: "$ title"]).bello();La query di aggregazione viene applicata alla collezione di libri per ottenere il valore distinto del documento di gruppo. Il gruppo $ qui prende l'espressione _id che emette i valori distinti in quanto abbiamo inserito il campo "titolo" ad esso. L'output del documento di gruppo è ottenuto all'esecuzione di questa query che ha il gruppo di nomi dei titoli contro il campo _id.
Conclusione
La guida mirava a cancellare il concetto dell'operatore di aggregazione del gruppo $ per raggruppare il documento nel database MongoDB. L'approccio aggregato MongoDB migliora i fenomeni di raggruppamento. La struttura di sintassi dell'operatore del gruppo $ è dimostrata con i programmi di esempio. Oltre all'esempio di base degli operatori del gruppo $, abbiamo anche impiegato questo operatore con alcuni accumulatori come $ push, $ min, $ somma e operatori come $ match e $ ordin.