Query in MongoDB: come funziona l’interrogazione dei dati

Le query in MongoDB consentono di cercare e analizzare il database in modo rapido ed efficace. La struttura del metodo è molto logica e prevede l’uso di numerosi parametri con cui è possibile specificare le query.

Ricerca efficace all’interno delle raccolte

In quanto soluzione NoSQL basata su documenti, MongoDB fornisce la possibilità di archiviare e gestire facilmente anche grandi e diverse quantità di dati. Il sistema di gestione dei database è molto flessibile e facilmente scalabile in orizzontale.

Al contrario dei database relazionali, qui i dati vengono memorizzati in documenti BSON (JSON binario) e raggruppati in raccolte. Per far sì che questo approccio funzioni davvero, sono necessari dei meccanismi di interrogazione forti, capaci di filtrare il database e di presentare solo le informazioni realmente necessarie. In MongoDB, le query sono in grado di cercare in raccolte anche molto ramificate e di fornire le informazioni desiderate.

Che cosa sono le query in MongoDB?

In MongoDB, le query costituiscono uno strumento di facile utilizzo per la ricerca di strutture di dati complesse. Esse seguono regole logiche e funzionano come le opzioni di filtro disponibili in molti siti web. In questo modo è possibile formulare la ricerca con estrema precisione e ottenere i risultati migliori. Questo aspetto è particolarmente importante perché MongoDB offre la possibilità di memorizzare molti tipi di dati diversi. In mancanza delle necessarie opzioni di filtro, sarebbe difficile gestire il database in modo soddisfacente. Di seguito descriveremo come creare facilmente query in MongoDB e come utilizzarle a proprio vantaggio.

Quali sono i requisiti per le query in MongoDB?

Per usufruire delle query in MongoDB sono necessari solo alcuni prerequisiti.

1. Per prima cosa è necessario installare MongoDB sul computer. Il database funziona su molti sistemi operativi, perciò per queste istruzioni non fa molta differenza se utilizzi Linux, OS X o Windows. I passaggi successivi all’installazione sono gli stessi su tutti i sistemi e riguardano solo il database stesso. Per sapere come funziona l’installazione, consulta il nostro tutorial su MongoDB.
2. Per la funzione di ricerca sono necessari anche i privilegi di amministrazione.
3. È consigliabile creare prima un ambiente di prova, in modo da poter provare il metodo senza rischi. Vediamo insieme come fare.

La struttura di una raccolta di prova

In primo luogo, apri la shell e accedi con i tuoi dati come amministratore o amministratrice. Successivamente, crea una nuova raccolta che fungerà da ambiente di prova per le prime query in MongoDB. Dal momento che il metodo può prendere in considerazione non solo documenti semplici, ma anche array, campi di vario genere e documenti integrati, realizzeremo una raccolta un po’ più complessa per dimostrare la portata delle query in MongoDB.

Nel nostro esempio, si tratta di un elenco di clienti. Il formato dell’elenco sarà il seguente:

{
    "name" : "Rossi",
    "units" : 642,
    "location" : [ "Italy", "Austria" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
}

Il presente documento contiene le seguenti informazioni:

• name: il nome dell’azienda cliente che ha acquistato la merce.
• units: la quantità totale di prodotti ordinati dall’azienda.
• location: la sede dell’altra azienda. Se ci sono più filiali, possono essere memorizzate sotto forma di array.
• transactions: in questo campo viene inserito un altro documento (in inglese si parla di “embedded documents” o “nested documents”). Ciascuno di questi documenti di transazione riporta informazioni su quanto tempo l’azienda è stata cliente (alla voce “first”), quando è stato effettuato l’ultimo ordine (alla voce “last”) e infine quante volte ha ordinato in totale (alla voce “total”).

In questo caso, i documenti aggiuntivi sono stati inseriti in modo da consentire l’aggiunta di ulteriori informazioni in un secondo momento. Ciò preserva la visione d’insieme.

Creare una raccolta di prova per le query in MongoDB

Ora creiamo una raccolta con il nome “Clienti”, che per il nostro esempio dovrebbe contenere solo cinque voci per una migliore visione d’insieme. Utilizzando in modo professionale le query in MongoDB in una fase successiva, è possibile creare raccolte molto più estese. Per farlo, si può ricorrere al metodo insertMany. Nel nostro esempio, il metodo si presenta così:

db.clienti.insertMany ( [
{
    "name" : "Rossi",
    "units" : 642,
    "location" : [ "Italy", "Austria" ],
    "transactions" : {
        "first" : {
            "year" : 2017,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 14
    }
},
{
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2,
    }
},
{
    "name" : "Meyer",
    "units" : 814,
    "location" : [ "Austria", "Italy" ],
    "transactions" : {
        "first" : {
            "year" : 2016,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 22,
    }
},
{
    "name" : "Pawolski",
    "units" : 313,
    "location" : [ "Italy", "Poland" ],
    "transactions" : {
            "first" : {
            "year" : 2017,
            },
        "last" : {
            "year" : 2020,
        },
        "total" : 9,
    }
},
{
    "name" : "Jorgensen",
    "units" : 7,
    "location" : "Denmark",
    "transactions" : {
        "first" : {
            "year" : 2022,
        },
        "last" : {
            "year" : 2023,
        },
        "total" : 2,
    }
}
] )

Eseguendo l’input in questo modo o con i propri dati, in cambio verrà fornito un elenco degli ID degli oggetti assegnati. Si tratta di dati univoci, con i quali si garantisce che ogni documento possa essere trovato tramite l’ID. Per assicurarti che tutti i documenti siano stati trasferiti nella raccolta, puoi avvalerti di MongoDB find e fare a meno di parametri aggiuntivi:

db.clienti.find ( )

L’output è un elenco di tutti gli ID degli oggetti con i documenti completi, in cui è possibile effettuare ricerche con le query di MongoDB.

Interrogare singoli campi con le query in MongoDB

Questo output da solo mette in evidenza il valore aggiunto offerto dalle query in MongoDB. Persino nel nostro semplice esempio, l’output produce lunghe stringhe di caratteri, rendendo molto difficile l’analisi senza l’ausilio di strumenti. Pertanto, anche dopo utilizzeremo il metodo find, specificando però la nostra ricerca. A tale scopo, definiamo un requisito speciale che il documento deve soddisfare per essere prodotto. Nell’esempio, cerchiamo tutti i documenti il cui nome corrisponde al valore “ATS”. L’input da inserire è questo:

db.clienti.find (
    { "name" : "ATS" }
)

Le semplici query in MongoDB di questo tipo ora effettuano una ricerca in tutti i documenti memorizzati nella raccolta corrispondente per trovare quelli che hanno il valore del nome “ATS”. Questa operazione riguarda solo una voce della nostra raccolta, per cui l’output si presenta in questo modo:

db.clienti.find ( { "name" : "ATS" } )
{
    "_id" : ObjectID ( "673d14684o75iftbb0ct5003" ),
    "name" : "ATS",
    "units" : 17,
    "location" : "France",
    "transactions" : {
        "first" : {
            "year" : 2021,
        },
        "last" : {
            "year" : 2022,
        },
        "total" : 2
    }

Anche il metodo opposto funziona. Se vuoi visualizzare tutti i risultati tranne la voce “ATS”, seleziona la voce seguente e otterrai di nuovo il risultato desiderato:

db.clienti.find (
    { "name" : { $ne : "ATS" } }
)

Se invece desideri produrre query in MongoDB con valori diversi, puoi farlo anche con un array. Nel nostro esempio, consideriamo i clienti “ATS” e “Jorgensen”.

db.clienti.find (
    { "name" : [ $in : [ "ATS", "Jorgensen" ] } }
)

Interrogare più campi con le query in MongoDB

Per avere risultati ancora più precisi, tuttavia, è necessario specificare ulteriormente la query. Le query in MongoDB possono essere specificate in modo ancora più preciso utilizzando parametri aggiuntivi. Specificando ora il valore del segmento “units” oltre al nome dell’azienda “ATS” per una query, viene ricercato un documento che contiene entrambi i valori:

db.clienti.find (
    { "name" : "ATS", "units" : 17 }
)

Anche in questo caso c’è una corrispondenza esatta. Se però uno dei due valori non è corretto, non verrà emesso alcun risultato in questo modo. Ad esempio, il seguente input non avrà successo:

db.clienti.find (
    { "name" : "ATS", "units" : 25 }
)

Per utilizzare invece le query in MongoDB così da prendere in considerazione valori diversi e inserire una voce già presente se almeno uno dei requisiti è soddisfatto, immetti il comando seguente:

db.clienti.find (
    { $or : [ {"name" : "ATS"}, { "units" : 25 } ] }
)

Interrogare i valori negli array

I valori negli array possono essere presi in considerazione anche con le query in MongoDB. Nell’esempio, ci sono aziende che hanno filiali in diversi paesi. Per visualizzare tutti i clienti che hanno almeno una filiale in Italia, l’input è molto semplice:

db.clienti.find (
    { "location" : "Italy" }
)

L’output include ora tutti e tre i clienti che hanno almeno una filiale in Italia. Se però desideri espandere l’input e recuperare contemporaneamente tutti i clienti con filiali in Italia e in Austria, usa un array:

db.clienti.find (
    { "location" : [ "Italy", "Austria" ] }
)

Noterai però che questo input mostra un solo risultato, anche se in teoria sono due le aziende che corrispondono ai criteri di ricerca. Il motivo è che le query di MongoDB tengono conto dell’input esatto e quindi, in questo caso, dell’ordine. Se quindi vuoi considerare valori che possono essere in qualsiasi ordine in un array, puoi completare la query come segue:

db.clienti.find (
    { "location" : { $all : [ "Italy", "Austria" ] } }
)

Query in MongoDB per documenti incorporati

Nel nostro esempio abbiamo utilizzato anche documenti incorporati. Anche questi possono essere restituiti con le query in MongoDB. A tale scopo, è necessario aggiungere un punto per segnalare a MongoDB che i campi di un documento incorporato devono essere analizzati. Ad esempio, se desideriamo un elenco di tutti i clienti che hanno più di dieci transazioni di ordine, inseriamo questo elemento:

db.clienti.find (
    { "transactions.total" : { $gt : 10 } }
)

Questo è il modo in cui MongoDB accede al documento “transactions” e poi prende in considerazione il numero di transazioni dell’ordine alla voce “total”.

Limitare l’output delle query

Anche con i metodi appresi finora, il risultato delle query in MongoDB può essere molto esteso. Di conseguenza, può essere utile limitare l’output a pochi campi. A tale scopo si utilizzano le cosiddette proiezioni. Esse contengono il valore 1 (per i campi inclusi) e 0 (per i campi da escludere). Nell’esempio che segue, realizziamo una query in due parti. Innanzitutto, viene avviata una ricerca senza parametri, che conterrebbe tutte le informazioni. Immediatamente dopo, però, viene effettuata una proiezione che prende in considerazione solo il campo del nome.

db.clienti.find (
    { }
    { "name" : 1 }
)

Così facendo si otterranno tutti i risultati, ma l’output sarà limitato ai rispettivi nomi.

Utilizzare i cursori per ottimizzare l’output

I cursori non sono un metodo per regolare i risultati delle query in MongoDB, ma per personalizzarne la visualizzazione. Per esempio, è possibile limitare il numero di risultati o modificarne l’ordine. Per visualizzare solo due risultati, utilizza il metodo limit. Funziona così:

db.clienti.find (
    { }
    { "name" : 1 }
).limit ( 2 )

Per ordinare l’output, serviti della seguente voce. Saranno visualizzate le tre persone che hanno ordinato il minor numero di prodotti:

db.clienti.find (
    { }
    { "name" : 1 }
).limit ( 2 ) .sort ( { "units" : 1 } )