Se usiamo MongoDB per conservare una grossa mole di informazioni, è probabile che prima o poi vorremo inviare delle query a scopo di analisi. Grazie all'Aggregation Framework di MongoDB possiamo configurare una pipeline per trasformare ed aggregare documenti. Quelli rappresentati nell'immagine seguente sono solo alcuni dei tipi di operazione configurabili nella pipeline.

Importare i dati di esempio

La collezione contiene i documenti di circa 25.000 ristoranti della città di New York. In ciascun documento si trovano i recapiti, il distretto di appartenenza, la posizione geografica e i giudizi di gradimento del ristorante. A differenza di quanto troveremmo in un database relazionale, tutte queste informazioni sono "vicine tra loro", pronte per essere visualizzate in una eventuale pagina web o per essere impiegate in attività di business intelligence.

Ora che i dati sono pronti, creiamo una nuova applicazione .NET Core ed installiamo il pacchetto MongoDB.Driver con il seguente comando:

dotnet add package MongoDB.Driver

Creare il modello

La classe principale verrà chiamata Rootobject ma siamo ovviamente liberi di rinominarla in Restaurant. Di solito sono necessari anche altri piccoli aggiustamenti, come aggiungere una proprietà per l'_id generato da MongoDb, di tipo ObjectId.

Match per filtrare

//Prima colleghiamoci alla collection restaurants del database test
var client = new MongoClient();
var database = client.GetDatabase("test");
var collection = database.GetCollection<Restaurant>("restaurants");

//Quindi avviamo l'aggregazione ed applichiamo il filtro
var restaurants = collection
  .Aggregate()
  .Match(r => r.borough == "Brooklyn" || r.borough == "Staten Island");

Ovviamente potremmo già stampare a video i risultati ma il nostro obiettivo, in questo caso, è di continuare la pipeline di aggregazione inserendo ulteriori stadi che ci portino ad ottenere dei dati sintetici.

Per configurare la nostra pipeline, il MongoDB Driver offre un'interfaccia fluente che ci permette di definire i vari stadi semplicemente continuando ad invocare i metodi l'uno dopo l'altro, analogamente a quanto già facciamo con LINQ, nell'interrogare collezioni di oggetti.

Group per raggruppare

• la prima indichierà la chiave di aggregazione, ovvero la proprietà borough;
• la seconda indicherà la proiezione, ovvero descriverà la forma dell'oggetto risultante dall'aggregazione. In esso inseriremo il nome del distretto e il conteggio dei ristoranti esistenti nel distretto.

var groups = restaurants.Group(r => 
  r.borough,
  group => new {
    borough = group.Key,
    count = group.Count()    
});

Da questo raggruppamento otterremo due risultati, uno per ogni distretto.

{ borough: "Staten Island", count: 969 }
{ borough: "Brooklyn", count: 6086 }

SortBy per ordinare

var sortedGroups = groups.SortBy(s => s.borough);

I risultati appariranno riordinati in questo modo:

{ borough: "Brooklyn", count: 6086 }
{ borough: "Staten Island", count: 969 }

Se avessimo voluto ordinare in maniera decrescente, avremmo usato SortByDescending. Inoltre, ThenBy e ThenByDescending ci permettono di ordinare per altre proprietà oltre la prima.

Lookup per il join con altre collezioni

{ borough: "Bronx", population: 1385108 }
{ borough: "Brooklyn", population: 2504700 }
{ borough: "Manhattan", population: 1585873 }
{ borough: "Queens", population: 2230722 }
{ borough: "Staten Island", population: 468730 }

Ora importiamo il file nella collection demographics del database test.

mongoimport --db test --collection demographics --drop --file c:\percorso\demographics.json

Ora che abbiamo un nuovo tipo di documento, facciamo creare a Visual Studio la classe Demographic, proprio come già fatto in precedenza per Restaurant.
Non resta che usare il metodo Lookup per eseguire la join tra i due insiemi di dati.

var demographics = database.GetCollection<Demographic>("demographics");
var joined = sortedGroups.Lookup(
  demographics,
  g => g.borough,
  d => d.borough,
  (LookedUpRestaurantGroup g) => g.demographics);

Nel metodo Lookup abbiamo indicato un nuovo tipo: la classe LookedUpRestaurantGroup che va anch'essa creata nel nostro progetto e che conterrà il risultato della join.

public class LookedUpRestaurantGroup
{
  public string _id {get; set;}
  public int count {get; set;}
  public IEnumerable<Demographic> demographics { get; set;}
}

Finalmente eseguiamo un ciclo per stampare il risultato della nostra aggregazione.

var results = await joined.ToListAsync();
foreach (var result in results) {
  Console.WriteLine($"{result._id}: {result.demographics.First().population/result.count} abitanti/ristorante");
}

Ed ecco l'output finale.

Brooklyn: 411 abitanti/ristorante
Staten Island: 483 abitanti/ristorante

Il Lookup è una funzionalità gradita, che è stata introdotta solo dalla versione 3.2 di MongoDb. Grazie ad essa è possibile creare query di aggregazione complesse, che possono avvalersi di vari dataset per estrarre conoscenza dalla mole di dati eterogenea a nostra disposizione.