Tutorial sulla dot notation in MongoDB: interrogare i campi annidati

Se hai appena iniziato a sperimentare con MongoDB, probabilmente sei arrivato al punto in cui i tuoi documenti iniziano a sembrare un po’ complessi. Questi documenti potrebbero essere passati da dati piatti, simili a quelli relazionali, a qualcosa con oggetti annidati, array annidati e magari anche quattro o cinque livelli di annidamento. Quindi, come interroghi questi dati quando sono a qualche livello di profondità?

In questo breve tutorial, vedremo la dot notation in MongoDB e come possiamo filtrare in modo molto rapido e semplice i nostri documenti in base a dati che contengono determinati valori nei campi annidati.

Quando parliamo di dot notation, ci riferiamo alla separazione dei campi annidati con un punto come delimitatore. Ad esempio:

root_field.nested_field_1.next_layer_nested_field_1

Per ogni livello di annidamento, aggiungiamo semplicemente un punto che separa quel livello quando effettuiamo la query. Vedremo esempi più approfonditi man mano che procediamo nel tutorial.

Se stai iniziando con MongoDB, dai un'occhiata al corso Introduction to MongoDB in Python di DataCamp.

Prerequisiti

Per avere successo con questo tutorial, devi avere un'istanza MongoDB distribuita e configurata. Questo significa che si presume tu sia pronto per iniziare a usare MongoDB. Dovresti anche avere almeno una familiarità di base con le query sulle collection in MongoDB. La documentazione può essere un buon punto di partenza se ti serve aiuto.

Per questo esempio, useremo i seguenti dati all'interno del database "dbinc" e della collection "people":

[
    {
        "name": "Nic Raboy",
        "websites": [
            {
                "type": "other",
                "name": "Portfolio",
                "url": "https://www.nraboy.com"
            },
            {
                "type": "social",
                "name": "LinkedIn",
                "url": "https://www.linkedin.com/in/nraboy"
            }
        ],
        "employment": {
            "employer": "MongoDB",
            "address": {
                "street": "1633 Broadway",
                "city": "New York",
                "state": "New York",
                "postal_code": 10019
            }
        }
    },
    {
        "name": "Tony Kim",
        "websites": [
            {
                "type": "social",
                "name": "LinkedIn",
                "url": "https://www.linkedin.com/in/hyung-kim/"
            },
            {
                "type": "coding",
                "name": "GitHub",
                "url": "https://github.com/hjkmines"
            }
        ],
        "employment": {
            "employer": "MongoDB",
            "address": {
                "street": "1633 Broadway",
                "city": "New York",
                "state": "New York",
                "postal_code": 10019
            }
        }
    }
]

I dati sopra rappresentano due documenti con un buon livello di complessità perché contengono oggetti e array annidati. Curiosità: MongoDB supporta più di 100 livelli di annidamento nei documenti BSON.

Se prevedi di seguire passo passo, assicurati che questi documenti esistano nella tua istanza MongoDB.

Interrogare i dati in MongoDB con vari approcci

Inizieremo con qualcosa di semplice e ci sposteremo gradualmente verso casi più complicati. La buona notizia è che complicato qui non significa necessariamente difficile.

Poniamo di voler trovare tutte le persone nella nostra collection che lavorano per MongoDB. Potremmo eseguire una query come la seguente:

use dbinc;

db.people.find({
	"employment.employer": "MongoDB"
});

In questo esempio, employer esiste come campo annidato all'interno dell'oggetto employment. Possiamo interrogare quel campo usando la dot notation, che è semplicemente l'uso di campi separati da un punto. Non sarebbe diverso se volessimo trovare tutte le persone che lavorano a New York. Potremmo fare qualcosa del genere:

use dbinc;

db.people.find({
	"employment.address.state": "New York"
});

Nella query sopra siamo scesi a tre livelli nel documento, e ha funzionato senza problemi.

Ora diamo un'occhiata a come lavorare con quell'array annidato di oggetti. Ci sono vari modi di interrogare, a seconda di cosa vogliamo ottenere.

Diciamo che vogliamo restituire tutte le persone che hanno un sito web "Portfolio" elencato. Potremmo eseguire una query come la seguente:

use dbinc;

db.people.find({
	"websites.name": "Portfolio"
});

La query sopra restituirebbe un solo risultato perché solo uno dei documenti ha "Portfolio" elencato. Nota che, anche se abbiamo un array, la dot notation funziona comunque. La nota importante è che "Portfolio" deve esistere da qualche parte all'interno di quell'array almeno una volta.

Ed è qui che le cose si fanno interessanti.

Poniamo di voler restringere ulteriormente i risultati restituiti. Lo faremmo aggiungendo più criteri di filtro, ma quando si lavora con oggetti annidati all'interno di array, le cose cambiano un po'. Prendi ad esempio quanto segue:

use dbinc;

db.people.find({
    "websites.name": "Portfolio",
    "websites.type": "social"
});

Nell'esempio sopra, stiamo dicendo che vogliamo risultati in cui sia "Portfolio" sia "social" esistano nell'array, ma non necessariamente nello stesso oggetto. Otteniamo un solo risultato perché il documento "Tony Kim" ha "social", ma non "Portfolio". Se ci servissero risultati in cui entrambi i campi devono esistere nello stesso oggetto, non potremmo usare la dot notation per farlo.

Anche se fuori dallo scopo di questo tutorial, usare l'operatore $elemMatch in questo modo risolverebbe il problema:

use dbinc;

db.people.find(
    { 
        "websites": { 
            "$elemMatch": { 
                "name": "Portfolio",
                "type": "social" 
            }
        }
    }
);

Nello scenario sopra non verrebbe restituito alcun risultato perché i nostri dati di esempio non hanno un name e un type corrispondenti nello stesso oggetto.

Se stai lavorando con array e conosci l'indice dell'array con cui vuoi lavorare, puoi continuare a usare la dot notation. Ad esempio, considera quanto segue:

use dbinc;

db.people.find({
    "websites.0.name": "Portfolio"
});

La query sopra usa l'indice dell'array su cui vuoi eseguire il match. In questo scenario, vogliamo restituire tutti i documenti in cui il primo elemento dell'array ha un name uguale a "Portfolio".

Sebbene sia fuori dallo scopo di questo tutorial, è importante sottolineare che la dot notation non è limitata alle query in sola lettura. Puoi usare la dot notation, come visto qui, nelle operazioni di update, nelle proiezioni e nelle pipeline di aggregazione.

Conclusione

Hai appena avuto un'introduzione rapida all'uso della dot notation nelle tue query MongoDB. Abbiamo imparato che:

• La dot notation funziona per gli oggetti annidati.
• Puoi usare la dot notation per gli array, ma con limitazioni a seconda delle aspettative su quegli array.
• L'operatore $elemMatch è necessario se vuoi effettuare il match di più campi all'interno di un singolo oggetto dell'array.
• Gli indici degli array nella dot notation possono essere usati se vuoi interrogare elementi specifici di un array.

I dati nelle tue collection MongoDB probabilmente non saranno piatti; ciò significa che a un certo punto avrai oggetti annidati, array annidati, array annidati in oggetti e qualsiasi altra combinazione di complessità. La buona notizia è che MongoDB rende semplice lavorare con queste informazioni grazie a una ricca API di query.

Se non stai ancora usando MongoDB, dai un'occhiata a MongoDB Atlas o al mio altro tutorial che mostra come iniziare con MongoDB e Docker. Puoi anche informarti sulla certificazione MongoDB nella nostra guida dedicata.