Come utilizzare la pipeline di aggregazione in MongoDB
Se MapReduce è stato il tuo punto di riferimento, ora potrebbe essere il momento di passare alla Aggregation Pipeline di MongoDB per affrontare operazioni complesse.
La pipeline di aggregazione è il modo consigliato per eseguire query complesse in MongoDB. Se utilizzi MapReduce di MongoDB, è meglio passare alla pipeline di aggregazione per calcoli più efficienti.
Cos'è l'aggregazione in MongoDB e come funziona?
La pipeline di aggregazione è un processo in più fasi per l'esecuzione di query avanzate in MongoDB. Elabora i dati attraverso diverse fasi chiamate pipeline. È possibile utilizzare i risultati generati da un livello come modello di operazione in un altro.
Ad esempio, puoi passare il risultato di un'operazione di corrispondenza a un'altra fase per ordinarlo in quell'ordine finché non ottieni l'output desiderato.
Ogni fase di una pipeline di aggregazione presenta un operatore MongoDB e genera uno o più documenti trasformati. A seconda della query, un livello può apparire più volte nella pipeline. Ad esempio, potresti dover utilizzare le fasi dell'operatore $count o $sort più di una volta nella pipeline di aggregazione.
Le fasi della pipeline di aggregazione
La pipeline di aggregazione passa i dati attraverso più fasi in un'unica query. Esistono diverse fasi e puoi trovare i dettagli nella documentazione di MongoDB.
Di seguito definiamo alcuni di quelli più comunemente utilizzati.
La fase $match
Questa fase consente di definire condizioni di filtraggio specifiche prima di avviare le altre fasi di aggregazione. Puoi utilizzarlo per selezionare i dati corrispondenti che desideri includere nella pipeline di aggregazione.
La fase a gironi
La fase a gironi separa i dati in diversi gruppi in base a criteri specifici utilizzando coppie chiave-valore. Ciascun gruppo rappresenta una chiave nel documento di output.
Ad esempio, considera i seguenti dati campione di vendite:
Utilizzando la pipeline di aggregazione, puoi calcolare il conteggio totale delle vendite e le vendite principali per ciascuna sezione di prodotto:
{
$group: {
_id: $Section,
total_sales_count: {$sum : $Sold},
top_sales: {$max: $Amount},
}
}
La coppia _id: $Section raggruppa il documento di output in base alle sezioni. Specificando i campi top_sales_count e top_sales, MongoDB crea nuove chiavi in base all'operazione definita dall'aggregatore; può essere $sum, $min, $max o $avg.
La fase $skip
Puoi utilizzare la fase $skip per omettere un numero specificato di documenti nell'output. Di solito arriva dopo la fase a gironi. Ad esempio, se si prevedono due documenti di output ma ne si salta uno, l'aggregazione produrrà solo il secondo documento.
Per aggiungere una fase di salto, inserisci l'operazione $skip nella pipeline di aggregazione:
...,
{
$skip: 1
},
La fase $sort
La fase di ordinamento consente di disporre i dati in ordine decrescente o crescente. Ad esempio, possiamo ordinare ulteriormente i dati nell'esempio di query precedente in ordine decrescente per determinare quale sezione ha le vendite più elevate.
Aggiungi l'operatore $sort alla query precedente:
...,
{
$sort: {top_sales: -1}
},
La fase $limit
L'operazione di limite aiuta a ridurre il numero di documenti di output che si desidera vengano visualizzati dalla pipeline di aggregazione. Ad esempio, utilizza l'operatore $limit per ottenere la sezione con le vendite più elevate restituite dalla fase precedente:
...,
{
$sort: {top_sales: -1}
},
{"$limit": 1}
Quanto sopra restituisce solo il primo documento; questa è la sezione con le vendite più elevate, poiché appare nella parte superiore dell'output ordinato.
La fase del progetto $
La fase $project ti consente di modellare il documento di output come preferisci. Utilizzando l'operatore $project, puoi specificare quale campo includere nell'output e personalizzarne il nome della chiave.
Ad esempio, un output di esempio senza la fase $project si presenta così:
Vediamo come appare con la fase $project. Per aggiungere il $project alla pipeline:
...,
{
"$project": {
"_id": 0,
"Section": "$_id",
"TotalSold": "$total_sales_count",
"TopSale": "$top_sales",
}
}
Poiché in precedenza abbiamo raggruppato i dati in base alle sezioni del prodotto, quanto sopra include ciascuna sezione del prodotto nel documento di output. Garantisce inoltre che il conteggio delle vendite aggregate e le vendite principali siano presenti nell'output come TotalSold e TopSale.
L'output finale è molto più pulito rispetto al precedente:
La fase di rilassamento
La fase $unwind suddivide un array all'interno di un documento in singoli documenti. Prendiamo ad esempio i seguenti dati Ordini:
Utilizza la fase $unwind per decostruire l'array di elementi prima di applicare altre fasi di aggregazione. Ad esempio, lo scioglimento dell'array articoli ha senso se desideri calcolare le entrate totali per ciascun prodotto:
db.Orders.aggregate(
[
{
"$unwind": "$items"
},
{
"$group": {
"_id": "$items.product",
"total_revenue": { "$sum": { "$multiply": ["$items.quantity", "$items.price"] } }
}
},
{
"$sort": { "total_revenue": -1 }
},
{
"$project": {
"_id": 0,
"Product": "$_id",
"TotalRevenue": "$total_revenue",
}
}
])
Ecco il risultato della query di aggregazione precedente:
Come creare una pipeline di aggregazione in MongoDB
Sebbene la pipeline di aggregazione includa diverse operazioni, le fasi descritte in precedenza forniscono un'idea di come applicarle nella pipeline, inclusa la query di base per ciascuna.
Utilizzando il precedente esempio di dati di vendite, analizziamo alcune delle fasi discusse sopra in un unico pezzo per una visione più ampia della pipeline di aggregazione:
db.sales.aggregate([
{
"$match": {
"Sold": { "$gte": 5 }
}
},
{
"$group": {
"_id": "$Section",
"total_sales_count": { "$sum": "$Sold" },
"top_sales": { "$max": "$Amount" },
}
},
{
"$sort": { "top_sales": -1 }
},
{"$skip": 0},
{
"$project": {
"_id": 0,
"Section": "$_id",
"TotalSold": "$total_sales_count",
"TopSale": "$top_sales",
}
}
])
L'output finale assomiglia a qualcosa che hai visto in precedenza:
Pipeline di aggregazione e MapReduce
Fino alla sua deprecazione a partire da MongoDB 5.0, il modo convenzionale per aggregare i dati in MongoDB era tramite MapReduce. Sebbene MapReduce abbia applicazioni più ampie oltre MongoDB, è meno efficiente della pipeline di aggregazione e richiede script di terze parti per scrivere la mappa e ridurre le funzioni separatamente.
La pipeline di aggregazione, invece, è specifica solo per MongoDB. Ma fornisce un modo più pulito ed efficiente per eseguire query complesse. Oltre alla semplicità e alla scalabilità delle query, le fasi della pipeline presenti rendono l'output più personalizzabile.
Esistono molte più differenze tra la pipeline di aggregazione e MapReduce. Li vedrai quando passi da MapReduce alla pipeline di aggregazione.
Rendi efficienti le query sui Big Data in MongoDB
La tua query deve essere il più efficiente possibile se desideri eseguire calcoli approfonditi su dati complessi in MongoDB. La pipeline di aggregazione è ideale per le query avanzate. Invece di manipolare i dati in operazioni separate, cosa che spesso riduce le prestazioni, l'aggregazione consente di raggrupparli tutti in un'unica pipeline performante ed eseguirli una volta.
Sebbene la pipeline di aggregazione sia più efficiente di MapReduce, puoi rendere l'aggregazione più rapida ed efficiente indicizzando i tuoi dati. Ciò limita la quantità di dati che MongoDB deve scansionare durante ogni fase di aggregazione.