Vad är MongoDB findOne och hur använder man det?

MongoDB:s findOne-metod är utmärkt för att söka i en samling. Den re­tur­ne­rar dock bara ett enda resultat, vilket gör den olämplig för många typer av sökningar.

Vad är MongoDB findOne?

MongoDB är ett da­ta­bashan­te­rings­sy­stem som enkelt kan lagra och hantera stora mängder data tack vare sin NoSQL-strategi och ena­stå­en­de skal­bar­het. Även om dessa aspekter erbjuder an­vän­dar­na betydande fördelar, innebär det också att systemet behöver kraft­ful­la metoder för att sä­ker­stäl­la att an­vän­dar­na effektivt kan navigera i databasen.

Systemet sparar alla typer av data i form av ett BSON-dokument (binär JSON) och samlar dessa dokument i samlingar. Om du vill söka efter och visa ett av dessa dokument finns det flera al­ter­na­tiv att välja mellan. Förutom den mer allmänna sök­me­to­den MongoDB find är MongoDB findOne en mycket effektiv metod för att filtrera stora databaser med precision.

MongoDB findOne söker igenom alla dokument och samlingar enligt vissa kriterier som anges av an­vän­da­ren. Det speciella med denna metod är att den alltid re­tur­ne­rar exakt ett dokument. Om det bara finns ett dokument i sökfrågan re­tur­ne­ras detta dokument. Om flera dokument matchar de pa­ra­met­rar som de­fi­ni­e­rats av an­vän­da­ren re­tur­ne­rar MongoDB findOne det dokument som visas först i da­ta­ba­sens naturliga ordning. Om inga dokument kan hittas i sökningen är re­sul­ta­tet ”null”.

Vad är syntaxen för MongoDB findOne?

Den grund­läg­gan­de syntaxen för MongoDB findOne är enkel. Metoden används på följande sätt:

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

Under <query> kan du ange hur metoden ska filtrera do­ku­men­ten.

Under <projection> kan du ange vilka fält som ska visas för det dokument som re­tur­ne­ras. Använd de booleska värdena 1 (sant/inkludera) och 0 (falskt/exkludera) för att ange om ett fält ska in­klu­de­ras. Om denna parameter förblir tom visas alla fält.

Den tredje sök­pa­ra­me­tern <options> gör det möjligt att yt­ter­li­ga­re modifiera sökningen och även ändra visningen. Alla tre sök­pa­ra­met­rar­na är valfria.

Hur man skapar en samling för te­stän­da­mål

Om du har in­stal­le­rat MongoDB på Linux, Windows eller Mac och vill använda MongoDB findOne är det värt att skapa en testmiljö för att ex­pe­ri­men­te­ra med metoden.

Om du ännu inte har skapat en databas kan du läsa vår om­fat­tan­de MongoDB-hand­led­ning för att lära dig hur man gör det. I vårt exempel nedan kommer vi att använda en an­ställds­da­ta­bas som in­ne­hål­ler fem poster. Varje post in­ne­hål­ler in­for­ma­tion om an­ställ­das namn, kön och ålder samt hur länge personen har varit anställd på företaget. Samlingen ser ut så här:

# Create Collection
db.employee.insertMany ( [
    {
    name : "Smith",
    gender : "Female",
    age : 56,
    year : 2002
    },
    {
    name : "Jones",
    gender : "Female",
    age : 40,
    year : 2017,
    },
    {
    name : "Brown",
    gender : "Male",
    age : 40,
    year : 2019
    },
    {
    name : "Michaels",
    gender : "Female",
    age : 44,
    year : 2015
    },
    name : "Cartwright",
    gender : "Male",
    age : 22,
    year : 2022
    }
]
)

Vilka olika sätt finns det att söka med Mongo DB findOne?

Det finns flera sätt att söka efter in­for­ma­tion med MongoDB findOne. Du kan söka utan pa­ra­met­rar, med ett ID, med ett fält eller med flera fält.

Sökning utan pa­ra­met­rar

Om du använder MongoDB-metoden findOne utan några pa­ra­met­rar kommer systemet att söka igenom din databas och ta hänsyn till alla poster. I vårt exempel innebär detta att metoden kommer att iden­ti­fi­e­ra fem poster. Eftersom inga dokument utesluts och metoden endast re­tur­ne­rar ett resultat kommer MongoDB findOne att välja den första personen som matades in i databasen.

db.employee.findOne ( )

Re­sul­ta­tet är:

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

Sökning efter ID

Normalt vill du ange någon form av kriterier för din sökning så att du hittar det dokument du faktiskt behöver. Ett sätt att söka efter dokument med MongoDB findOne är att söka efter ett ID.

Fältet _id är unikt i varje dokument. I vårt exempel re­pre­sen­te­rar varje ID exakt en anställd. Om du kör MongoDB findOne med objekt-ID:t får du exakt det resultat du söker.

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

Re­sul­ta­tet ser ut så här:

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

Söka med hjälp av specifika fält

Om du inte känner till ID:t eller vill söka i din samling efter andra pa­ra­met­rar kan du också använda MongoDB findOne för att söka efter specifika fält. Om det bara finns ett dokument som matchar pa­ra­me­tern är det det do­ku­men­tet som visas. Om flera dokument matchar dina sök­kri­te­ri­er visar systemet dock bara den första posten.

I exemplet nedan ska vi söka efter alla poster där könet är angivet som ”Man”. Här är kommandot:

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

Det finns två poster som matchar dessa kriterier, men endast en visas. Re­sul­ta­tet visar den anställde Mr Brown:

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

Söka med hjälp av flera fält

Du har också möjlighet att begränsa sökningen yt­ter­li­ga­re för att undvika över­lapp­ning­ar. Detta är kanske inte nöd­vän­digt för vår lilla samling av exempel, men om du arbetar med flera hundra eller till och med tusentals poster kan denna funktion vara användbar. MongoDB findOne låter dig använda flera fält för sökningen. Om du vill iden­ti­fi­e­ra en anställd efter kön (man) och ålder kan du skriva följande:

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

Re­sul­ta­tet visar återigen Mr Brown, som är den enda personen i samlingen som är man och 40 år gammal. Ms Jones är i samma ålder, men hennes kön stämmer inte överens med kri­te­ri­er­na, så re­sul­ta­tet ser ut så här:

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

Hur man ställer in villkor för ett fält med MongoDB findOne

Det är också möjligt att definiera villkor för ett specifikt fält och använda dessa som sök­kri­te­ri­er. I följande exempel söker vi endast efter anställda som är över 30 år.

Denna post ser ut så här:

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

Detta utesluter Mr Car­twright. Eftersom Ms Smith är över 30 år och är den första personen i listan visas hon som resultat:

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

Hur man utesluter fält med MongoDB findOne

Om du har om­fat­tan­de samlingar som in­ne­hål­ler mycket in­for­ma­tion kan utdata innehålla för mycket in­for­ma­tion. Lyck­ligt­vis erbjuder MongoDB findOne också möj­lig­he­ten att utesluta fält från utdata. I följande exempel vill vi inte visa ID, kön och ålder i utdata.

db.employee.findOne ( { name : "Smith" }, { _id : 0, gender : 0, age : 0 } )

Du får följande resultat:

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

Vad händer om MongoDB findOne inte hittar några resultat för min sökning?

Om det inte finns några resultat för din sökning med MongoDB findOne visas ändå ett resultat. För att il­lu­stre­ra vad som händer söker vi efter Ms. Larkham, som inte finns i samlingen.

db.employee.findOne ( { name : "Larkham" }  )

Re­sul­ta­tet för detta är:

db.employee.findOne ( { name : "Larkham" }  )
null