MongoDB findOne: istruzioni ed esempi di utilizzo

Il metodo findOne di MongoDB è molto efficace per le ricerche all’interno di una raccolta. Tuttavia, restituisce solo un risultato alla volta, motivo per cui non è adatto a tutte le esigenze.

Che cos’è findOne di MongoDB?

MongoDB è un sistema di gestione di database in grado di memorizzare e gestire facilmente anche grandi quantità di dati grazie al suo approccio NoSQL e alla sua elevata scalabilità. Sebbene questo sia un grande vantaggio, richiede anche metodi efficaci per garantire che l’utente mantenga una visione d’insieme quando lavora con il database.

Il sistema salva i dati di tutti i tipi sotto forma di un documento BSON (JSON binario) e li raggruppa in raccolte. Per cercare e ottenere uno di questi documenti, sono disponibili diverse opzioni. Oltre al più generale MongoDB find, findOne è in particolare un metodo molto efficace per filtrare con precisione anche database molto estesi.

MongoDB findOne cerca tutti i documenti e le raccolte considerate in base a determinati criteri che possono essere specificati dall’utente. La particolarità di questo metodo è che restituisce sempre un unico documento corrispondente ai parametri memorizzati. Se nella query di ricerca compare un solo documento, verrà preso in considerazione questo. Se sono presenti più documenti, findOne in MongoDB restituisce il documento che appare per primo nell’ordine naturale del database. Se non è possibile trovare alcun documento nella ricerca, l’output è “zero”.

Sintassi e caratteristiche speciali di findOne in MongoDB

La sintassi di base di findOne in MongoDB è molto chiara. Il metodo viene sempre utilizzato come segue:

db.collection.findOne ( <query>, <projection>, <options> )

I parametri di ricerca in base ai quali il metodo deve filtrare i documenti sono specificati in <query>. Questo input è facoltativo. Le voci sotto <projection> determinano quali campi vengono presi in considerazione per il documento visualizzato. I valori ammessi per l’output sono i valori booleani 1 (o true/vero) e 0 (o false/falso). Se questa specifica rimane vuota, vengono sempre visualizzati tutti i campi. Si tratta dunque di una specifica opzionale. <options> consente di modificare ulteriormente la ricerca e di cambiare la visualizzazione. Anch’essa è facoltativa.

Creare una raccolta di prova

Se hai installato MongoDB su Linux, Windows o Mac e vorresti usare findOne, ti consigliamo di creare un ambiente di prova per prendere confidenza con il metodo. Trovi una guida dettagliata al riguardo nel nostro tutorial di MongoDB. Per il nostro esempio, immaginiamo un database di dipendenti che contiene cinque voci e informazioni su nome, sesso ed età del dipendente. Ci sono anche informazioni sulla durata del rapporto con l’azienda. Questa raccolta ha il seguente aspetto:

db.dipendente.insertMany ( [
    {
    name : "Rossi",
    gender : "Female",
    age : 56,
    year : 2002
    },
    {
    name : "Ferrari",
    gender : "Female",
    age : 40,
    year : 2017,
    },
    {
    name : "Perez",
    gender : "Male",
    age : 40,
    year : 2019
    },
    {
    name : "Schulz",
    gender : "Female",
    age : 44,
    year : 2015
    },
    name : "Esposito",
    gender : "Male",
    age : 22,
    year : 2022
    }
]
)

findOne in MongoDB: ricerca senza parametri

Utilizzando il metodo findOne in MongoDB senza alcun parametro, il sistema cercherà nel database e troverà cinque voci da prendere in considerazione. Poiché nessun documento è escluso, tutti e cinque i dipendenti sono idonei. Di conseguenza, findOne selezionerà la prima persona inserita nel database, perché il metodo restituisce sempre un solo risultato. Il nostro esempio si presenta quindi nel modo seguente:

db.dipendente.findOne ( )

Il risultato sarà il seguente:

db.dipendente.findOne ( )
{
    _id : ObjectID ( "529ete7300of4002bme148om" ),
    name : "Rossi",
    gender : "Female",
    age : 56,
    year : 2002
}

Ricerca delle voci per ID

Normalmente, però, la ricerca deve essere specificata in modo da non ottenere un documento qualsiasi, ma quello di cui si ha effettivamente bisogno. MongoDB findOne offre gli strumenti giusti anche per fare ciò. Un metodo molto sicuro è la ricerca per ID. Il campo _id è unico in ogni documento e quindi nel nostro esempio può sempre essere assegnato a un unico dipendente. Pertanto, se si esegue findOne in MongoDB utilizzando l’ID dell’oggetto, si otterrà il risultato desiderato. Nel nostro esempio, il risultato è questo:

db.dipendente.findOne ( { _id : ObjectID ( "582pfh773813tw982qj411l0" ) } )

L’output si presenterebbe così:

db.dipendente.findOne ( { _id : ObjectID ( "582pfh773813tw982qj411l0" ) } )
{
    _id : ObjectID ( "582pfh773813tw982qj411l0"
    name : "Esposito",
    gender : "Male",
    age : 22,
    year : 2022
}

Ricerca in campi specifici con findOne in MongoDB

Se però non si conosce l’ID o si desidera cercare altri parametri all’interno della raccolta, si può anche usare findOne in MongoDB per ricercare campi specifici. Anche in questo caso vale quanto segue: se esiste un unico documento che corrisponde al parametro, verrà visualizzato questo. Tuttavia, se ai criteri di ricerca corrispondono più documenti, il sistema visualizzerà solo la prima voce. Nel nostro esempio, quindi, cerchiamo tutte le voci che specificano “Male” come genere. Le voci corrispondenti, in teoria, sono due. Tuttavia, verrà visualizzato solo il primo risultato. Il comando corrispondente funziona quindi così:

db.dipendente.findOne ( { gender : "Male" } )

L’output mostra quindi il dipendente Perez:

db.dipendente.findOne ( { gender : "Male" } )
{
    _id : ObjectID ( "498p0t173mv489fh63th00kh"
    name : "Perez",
    gender : "Male",
    age : 40,
    year : 2019
}

findOne in MongoDB: restringere la ricerca

Naturalmente, è possibile restringere ulteriormente la ricerca per evitare sovrapposizioni. Questo potrebbe non essere necessario nel nostro piccolo campionario, ma se si lavora con diverse centinaia o addirittura migliaia di voci, questa funzione diventa molto utile. MongoDB findOne consente di utilizzare diversi campi per la ricerca. Nel caso in cui si voglia identificare un dipendente in base al sesso (maschio) e all’età, il comando apparirà in questo modo:

db.dipendente.findOne ( { gender : "Male", age: 40 } )

L’output mostra di nuovo il dipendente Perez, che è l’unica persona della raccolta di sesso maschile e di 40 anni. La signora Ferrari avrebbe avuto la stessa età, ma è una donna. L’output corrispondente è il seguente:

db.dipendente.findOne ( { gender : "Male", age: 40 } )
{
    _id : ObjectID ( "498p0t173mv489fh63th00kh"
    name : "Perez",
    gender : "Male",
    age : 40,
    year : 2019
}

Impostare le condizioni per un campo

È anche possibile definire condizioni per un campo specifico e utilizzarle come criteri di ricerca. Nell’esempio seguente, consideriamo solo le persone che hanno più di 30 anni.

In questo caso il comando da immettere è il seguente:

db.dipendente.findOne ( { age : { $gt : 30 } } )

Questo esclude il dipendente Esposito. Poiché la signora Rossi soddisfa il criterio ed è la prima persona nell’elenco, viene visualizzata nuovamente:

db.dipendente.findOne ( { age : { $gt : 30 } } )
{
    _id : ObjectID ( "529ete7300of4002bme148om" ),
    name : "Rossi",
    gender : "Female",
    age : 56,
    year : 2002
}

Escludere i campi con findOne in MongoDB

Soprattutto nel caso di raccolte estese che contengono molte informazioni, l’output può diventare talvolta confuso. Per questo motivo, findOne in MongoDB offre la possibilità di escludere singoli campi dall’output. Nell’esempio seguente, non vogliamo che vengano visualizzati l’ID, il sesso e l’età.

db.dipendente.findOne ( { name : "Rossi" }, { _id : 0, gender : 0, age : 0 } )

Si otterrà il seguente risultato:

db.dipendente.findOne ( { name : "Rossi" }, { _id : 0, gender : 0, age : 0 } )
{
    name : "Rossi",
    year : 2002
}

Esempio di ricerca non riuscita

I risultati della ricerca con findOne in MongoDB vengono visualizzati anche nel caso in cui non vi siano riscontri. Cerchiamo quindi il dipendente Bernardi, che non è presente nella raccolta.

db.dipendente.findOne ( { name : "Bernardi" }  )

L’output apparirà come segue:

db.dipendente.findOne ( { name : "Bernardi" }  )
null