MongoDB villkorliga operatorer ange ett villkor som värdet på dokumentfältet ska motsvara.
Jämförelsefrågeoperatörer
- $eq (lika)
- $ne (inte lika)
- $gt (mer än)
- $lt (mindre än)
- $gte (mer eller lika)
- $lte (mindre eller lika)
- $in definierar en uppsättning värden, varav ett ska ha ett dokumentfält
- $nin definierar en matris med värden som inte ska ha ett dokumentfält
Vi hittar till exempel alla dokument som har ett åldersnyckelvärde mindre än 30:
db.users.find ({age: {$lt : 30}})
Användningen av andra jämförelseoperatorer kommer att vara liknande. Till exempel samma nyckel, bara över 30:
db.users.find ({age: {$gt : 30}})
Observera att jämförelsen här görs över heltalstyper, inte strängar. Om nyckelåldern representerar strängvärden bör jämförelsen göras över raderna:db.users.find ({age:{$gt :“30”}}), men resultatet blir detsamma.
Men låt oss föreställa oss en situation där vi måste hitta alla volymer med ett åldersfältvärde som är större än 30 men mindre än 50. I det här fallet kan vi kombinera två operatorer:
db.users.find ({age: {$gt : 30, $lt: 50}})
Vi kommer att hitta användare vars ålder är 22:
db.users.find ({age: {$eq : 22}})
Detta är i huvudsak analogin till nästa fråga:
db.users.find ({age: 22})
Omvänd operation – hitta användare vars ålder INTE är 22:
db.users.find ({age: {$ne : 22}})
Operatorn $in definierar en array av möjliga uttryck och söker efter de nycklar vars värde finns i arrayen:
db.users.find ({age: {$in : [22, 32]}})
På motsatt sätt definierar operatorn $nin en array av möjliga uttryck och söker efter de nycklar vars värde saknas i denna array:
db.users.find ({ålder:{$nin:[22, 32]}})
Logiska operatorer
Logiska operatorer körs över samplingsvillkor:
- $or :kopplar samman två villkor, och dokumentet måste uppfylla ett av dessa villkor
- $and: kopplar samman två villkor, och dokumentet måste uppfylla båda villkoren
- $not: dokumentet får INTE matcha villkoret
- $nor: kopplar samman två villkor, och dokumentet får INTE uppfylla båda villkoren
MongoDB Exempeloperatorer
Operatorn $or representerar en logisk ELLER-operation och definierar en uppsättning nyckel-värdepar som ska finnas i ett dokument. Och om ett dokument har minst ett sådant nyckel-värdepar, motsvarar det den här frågan och extraheras från databasen:
db.users.find ({$or : [{name: "Tom"}, {age: 22}]})
Detta uttryck returnerar alla dokument med antingen name=Tom eller age=22.
Ett annat exempel kommer att returnera alla dokument med antingen name=Tom och age=22 eller med "german" bland språkvärdena:
db.users.find ({name: "Tom", $or : [{age: 22}, {languages: "german"}]})
Villkorliga operatorer kan användas i underuttryck eller underuttryck:
db.users.find ({$or : [{name: "Tom"}, {age: {$gte:30}}]})
I det här fallet väljer vi alla dokument där namn=”Tom” eller åldersfältet har ett värde på 30 eller högre.
Operator $and
Operatorn $and representerar en logisk operation AND (logisk multiplikation) och definierar en uppsättning kriterier som ett dokument måste uppfylla. Till skillnad från $or-operatören måste dokumentet uppfylla alla angivna kriterier. Till exempel:
db.users.find ({$and : [{name: "Tom"}, {age: 32}]})
Här måste de valda dokumenten ha namnet Tom och ålder 32 – båda dessa funktioner.
MongoDB Array-sökning
Vissa operatorer är utformade för att fungera med arrayer:
- $all: definierar en uppsättning värden som ska finnas i en array
- $size: definierar antalet element som ska finnas i en array
- $elemMatch: anger villkoret som elementen i arrayen måste motsvara
MongoDB $all
Operatorn $all definierar en rad möjliga uttryck och kräver att dokument har hela den definierade uppsättningen uttryck. Följaktligen används den för att söka i arrayen. Till exempel har dokument en rad språk som lagrar de främmande språk som talas av användaren. Och för att hitta alla personer som talar både engelska och franska samtidigt kan vi använda följande uttryck:
db.users.find ({languages: {$all : ["english", "french"]}})
Operator $elemMatch
Operatorn $elemMatch låter dig välja dokument där arrayer innehåller element som faller under vissa villkor. Låt till exempel databasen innehålla en samling användarbetyg för specifika kurser. Låt oss lägga till några dokument:
db.grades.insertMany([{student: "Tom", courses:[{name: "Java", grade: 5}, {name: "MongoDB", grade: 4}]},
{student: "Alice", courses:[{name: "C++", grade: 3}, {name: "MongoDB", grade: 5}]}))
Varje dokument har en array, som i sin tur består av kapslade dokument.
Nu ska vi hitta elever som har betyg över 3 på MongoDB-kursen:
db.grades.find({courses: {$elemMatch: {name: "MongoDB", grade: {$gt: 3}}}})
Operator $size
Operatorn $size används för att hitta dokument där arrayer har ett antal element lika med värdet på $size. Låt oss till exempel extrahera alla dokument där det finns två element i språkarrayen:
db.users.find ({languages: {$size:2}})
En sådan fråga kommer till exempel att motsvara följande dokument:
{"name": "Tom", "age": 32, languages: ["english", "german"]}
Operator $finns
Operatorn $exists tillåter att endast extrahera de dokument där en viss nyckel finns eller saknas. Till exempel returnera alla dokument som innehåller företagsnyckeln:
db.users.find ({company: {$exists:true}})
Om vi anger $exists som den falska parametern, returnerar frågan endast de dokument som inte innehåller företagsnyckeln.
Operator $type
Operatorn $type extraherar endast de dokument där en viss nyckel har ett värde av en viss typ, t.ex. en sträng eller ett nummer:
db.users.find ({age: {$type: "string"}})
> db.users.find ({age: {$type: "number"}})
Operator $regex
Operatorn $regex anger ett reguljärt uttryck som fältvärdet ska motsvara . Låt till exempel fältnamnet nödvändigtvis ha bokstaven "b":
db.users.find ({name: {$regex: "b"}})
Det är viktigt att förstå att $regex inte bara tar strängar, utan reguljära uttryck, till exempel:namn:{$regex:“om$”} – värdet på namn måste sluta med “om”.