MongoDB findOne: istru­zio­ni ed esempi di utilizzo

Il metodo findOne di MongoDB è molto efficace per le ricerche all’interno di una raccolta. Tuttavia, re­sti­tui­sce 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 me­mo­riz­za­re e gestire fa­cil­men­te anche grandi quantità di dati grazie al suo approccio NoSQL e alla sua elevata sca­la­bi­li­tà. 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 di­spo­ni­bi­li diverse opzioni. Oltre al più generale MongoDB find, findOne è in par­ti­co­la­re un metodo molto efficace per filtrare con pre­ci­sio­ne anche database molto estesi.

MongoDB findOne cerca tutti i documenti e le raccolte con­si­de­ra­te in base a de­ter­mi­na­ti criteri che possono essere spe­ci­fi­ca­ti dall’utente. La par­ti­co­la­ri­tà di questo metodo è che re­sti­tui­sce sempre un unico documento cor­ri­spon­den­te ai parametri me­mo­riz­za­ti. Se nella query di ricerca compare un solo documento, verrà preso in con­si­de­ra­zio­ne questo. Se sono presenti più documenti, findOne in MongoDB re­sti­tui­sce il documento che appare per primo nell’ordine naturale del database. Se non è possibile trovare alcun documento nella ricerca, l’output è “zero”.

Sintassi e ca­rat­te­ri­sti­che speciali di findOne in MongoDB

La sintassi di base di findOne in MongoDB è molto chiara. Il metodo viene sempre uti­liz­za­to come segue:

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

I parametri di ricerca in base ai quali il metodo deve filtrare i documenti sono spe­ci­fi­ca­ti in <query>. Questo input è fa­col­ta­ti­vo. Le voci sotto <projection> de­ter­mi­na­no quali campi vengono presi in con­si­de­ra­zio­ne per il documento vi­sua­liz­za­to. 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 vi­sua­liz­za­ti tutti i campi. Si tratta dunque di una specifica opzionale. <options> consente di mo­di­fi­ca­re ul­te­rior­men­te la ricerca e di cambiare la vi­sua­liz­za­zio­ne. Anch’essa è fa­col­ta­ti­va.

Creare una raccolta di prova

Se hai in­stal­la­to MongoDB su Linux, Windows o Mac e vorresti usare findOne, ti con­si­glia­mo di creare un ambiente di prova per prendere con­fi­den­za con il metodo. Trovi una guida det­ta­glia­ta al riguardo nel nostro tutorial di MongoDB. Per il nostro esempio, im­ma­gi­nia­mo un database di di­pen­den­ti che contiene cinque voci e in­for­ma­zio­ni su nome, sesso ed età del di­pen­den­te. Ci sono anche in­for­ma­zio­ni sulla durata del rapporto con l’azienda. Questa raccolta ha il seguente aspetto:

# Create Collection
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

Uti­liz­zan­do il metodo findOne in MongoDB senza alcun parametro, il sistema cercherà nel database e troverà cinque voci da prendere in con­si­de­ra­zio­ne. Poiché nessun documento è escluso, tutti e cinque i di­pen­den­ti sono idonei. Di con­se­guen­za, findOne se­le­zio­ne­rà la prima persona inserita nel database, perché il metodo re­sti­tui­sce 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

Nor­mal­men­te, però, la ricerca deve essere spe­ci­fi­ca­ta in modo da non ottenere un documento qualsiasi, ma quello di cui si ha ef­fet­ti­va­men­te 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 di­pen­den­te. Pertanto, se si esegue findOne in MongoDB uti­liz­zan­do l’ID dell’oggetto, si otterrà il risultato de­si­de­ra­to. Nel nostro esempio, il risultato è questo:

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

L’output si pre­sen­te­reb­be 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 cor­ri­spon­de al parametro, verrà vi­sua­liz­za­to questo. Tuttavia, se ai criteri di ricerca cor­ri­spon­do­no più documenti, il sistema vi­sua­liz­ze­rà solo la prima voce. Nel nostro esempio, quindi, cerchiamo tutte le voci che spe­ci­fi­ca­no “Male” come genere. Le voci cor­ri­spon­den­ti, in teoria, sono due. Tuttavia, verrà vi­sua­liz­za­to solo il primo risultato. Il comando cor­ri­spon­den­te funziona quindi così:

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

L’output mostra quindi il di­pen­den­te Perez:

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

findOne in MongoDB: re­strin­ge­re la ricerca

Na­tu­ral­men­te, è possibile re­strin­ge­re ul­te­rior­men­te la ricerca per evitare so­vrap­po­si­zio­ni. Questo potrebbe non essere ne­ces­sa­rio nel nostro piccolo cam­pio­na­rio, ma se si lavora con diverse centinaia o ad­di­rit­tu­ra migliaia di voci, questa funzione diventa molto utile. MongoDB findOne consente di uti­liz­za­re diversi campi per la ricerca. Nel caso in cui si voglia iden­ti­fi­ca­re un di­pen­den­te 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 di­pen­den­te 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 cor­ri­spon­den­te è il seguente:

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

Impostare le con­di­zio­ni per un campo

È anche possibile definire con­di­zio­ni per un campo specifico e uti­liz­zar­le come criteri di ricerca. Nell’esempio seguente, con­si­de­ria­mo 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 di­pen­den­te Esposito. Poiché la signora Rossi soddisfa il criterio ed è la prima persona nell’elenco, viene vi­sua­liz­za­ta nuo­va­men­te:

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

Escludere i campi con findOne in MongoDB

So­prat­tut­to nel caso di raccolte estese che con­ten­go­no molte in­for­ma­zio­ni, l’output può diventare talvolta confuso. Per questo motivo, findOne in MongoDB offre la pos­si­bi­li­tà di escludere singoli campi dall’output. Nell’esempio seguente, non vogliamo che vengano vi­sua­liz­za­ti 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 vi­sua­liz­za­ti anche nel caso in cui non vi siano riscontri. Cerchiamo quindi il di­pen­den­te Bernardi, che non è presente nella raccolta.

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

L’output apparirà come segue:

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