MongoDB ELLER Operatör

Mongodb Eller Operator



Vi har olika logiska frågeoperatorer som är tillgängliga i MongoDB, och en av dem är $or-operatören. MongoDB $or-operatorn används för att implementera en logisk ELLER-operation på en array som innehåller två eller flera uttryck och hämtar endast de dokument som matchar något av de angivna uttrycken i arrayen. Operatorn $or används för att hitta flera satser i en enda fråga med bara ett matchande dokumentkriterium. Operatorn $or underlättar kombinationen av flera nycklar och värden.

Hur man använder OR-operatören i MongoDB

OR-operatorn i MongoDB representeras i formatet '$or'. '$or' används för att omsluta de multipla uttrycken inom hakparenteser där den logiska ELLER-operationen utförs. Vi använder operatorn $or på MongoDB-samlingen. Vi skapar MongoDB-kollektionen som heter 'Patienter'. 'Patienter'-samlingen infogas med de flera dokument som vi utför $or-operatören på. Följande dokument infogas i MongoDB genom att anropa metoden insertMany():

db.Patients.insertMany ( [
{
'Förnamn' : 'Jennifer' ,
'Efternamn' : 'Joshua' ,
'Ålder' : 44 ,
'Telefonnummer' : 43400517 ,
'Utnämning' : 'Tandläkare' ,
'Kostnader' : 2000 ,
'Testa' : [ 'röntgen' , 'Blod' , 'Pulpal' ]
} ,
{
'Förnamn' : 'Thomas' ,
'Efternamn' : 'Steven' ,
'Ålder' : 74 ,
'Telefonnummer' : 39034694 ,
'Utnämningsdagen' : 'Kirurg' ,
'Kostnader' : 6000 ,
'Testa' : [ 'Valfri' , 'PPT' ]
} ,
{
'Förnamn' : 'Charles' ,
'Efternamn' : 'Daniel' ,
'Ålder' : 35 ,
'Telefonnummer' : 65712165 ,
'Utnämning' : 'Kardiologisk läkare' ,
'Kostnader' : 2000 ,
'Testa' : [ 'CT' , 'MRI' ]
} ,
{
'Förnamn' : 'Michelle' ,
'Efternamn' : 'Paul' ,
'Ålder' : 51 ,
'Telefonnummer' : 54399288 ,
'Utnämning' : 'Hudläkare' ,
'Kostnader' : 8000 ,
'Testa' : [ 'Hudbiopsier' , 'Träljus' , 'Hudskrapning' ]
} ,

{
'Förnamn' : 'Andrew' ,
'Efternamn' : 'Jerry' ,
'Ålder' : 69 ,
'Telefonnummer' : 6108100 ,
'Utnämning' : 'Kardiologisk läkare' ,
'Kostnader' : 7000 ,
'Testa' : [ 'EKG' , 'Blodsocker' , 'Ultraljud' ]
}
] )

Utdata från de tidigare infogade dokumenten bekräftar 'true' och ger 'insertedIds'-värdena för varje dokument.









Exempel 1: MongoDB $OR Operator för att matcha dokumenten

Den grundläggande frågan för MongoDB $or-operatören implementeras här, vilket visar hur denna operatör fungerar i MongoDB. Här definierar vi en fråga med metoden find(). Metoden find() specificeras ytterligare med operatorn $or. $or-operatören tar två fält, 'Avbokning' och 'Avgifter', som tilldelas värdena. Operatorn $or matchar fältvärdet och hämtar endast de dokument vars värden matchas med fältvärdena. Frågestrukturen för $or-operatorn finns i följande:



db.Patients.find ( { $eller : [ { Utnämning: 'Hudläkare' } ,
{ Kostnader: 7000 } ] } ) .Söt ( )

Vi hämtar dokumenten vars 'Avbokning' är hos 'Hudläkare' och vars 'Avgifter' är '7000'. Operatören $or hittar sanna resultat från båda fältvärdena och returnerar de matchade dokumenten i utdata.





Exempel 2: MongoDB $OR Operator för att matcha de icke-existerande dokumenten

I den tidigare frågan från $or-operatören hämtade vi de matchade dokumenten. Nu hämtar vi det icke-existerande dokumentet från 'Patient'-samlingen. Följande $or operatörsfråga tar dokumentet vars 'FirstName' är 'Charles' och 'Avnämningen' är med 'Physician'. $or-operatören matchar dessa fältvärden inom samlingen 'Patienter' och genererar resultaten efter matchning.



db.Patients.find ( { $eller : [ { 'Förnamn' : 'Charles' } , { 'Utnämning' : 'Läkare' } ] } ) .Söt ( )

Operatorn $or har ett sant resultat och det andra har ett falskt resultat. Eftersom vi anger 'Avbokning' med värdet 'Läkare' som inte matchar något av dokumenten i 'Patient'-samlingen. Det är därför, $or-operatören endast returnerar dokumentet för det matchade fältet som är 'Patient' som utdata.

Exempel 3: MongoDB $OR-operatör med flera argument

Vi angav två argument i de tidigare $or-operatörsfrågorna. Här skickar vi mer än två argument som operatoruttrycket $or. Vi hämtar dokumentet som matchar något av 'Ålder'-fältvärdena som ges till det. Operatorkravet $or är detsamma för de flera argumenten att ett av uttrycken ska vara sant. Frågan för flera argument i $or-operatorn ges enligt följande:

db.Patients.find ( { 'Utnämning' : 'Kardiologisk läkare' , $eller : [ { 'Ålder' : tjugo } , { 'Ålder' : 35 } , { 'Ålder' : 69 } ] } )

Där har vi två matchade resultat som erhålls från $or-operatören. 'Ålder'-värdena som är '35' och '69' jämförs med 'Patientdokumenten' som erhålls av $or-operatören och visas på skalet.

Exempel 4: MongoDB $OR-operatör med aggregation

Den aggregerade metoden i MongoDB kombinerar posterna till en samling. Därför kan de användas för olika operationer. Vi utför operatorn $or i aggregeringsmetoden som utvärderar ett eller flera uttryck och returnerar sant om något av dem utvärderas till sant. I annat fall anses påståendet vara falskt.

Låt oss ha $or aggregationsoperatorfrågan där vi först anropar metoden aggregate() som sedan distribuerar $match och $project som specificeras med _id-värdet som ska matchas från dokumentet. Sedan ställer vi in ​​'Ålder'-fältet med värdet '1' eftersom vi bara vill att det här fältet ska genereras från alla dokument. Efter det definierar vi attributet 'Results' som har $or-operationen. Operatören $or tar det villkorliga uttalandet $gt. Uttrycket '$gt:['$Age', 69]' ger åldern vars värde är större än '69'. Resultaten för detta uttryck skickas till operatorn $or och operatorn $or returnerar dokumentet som uppfyller det angivna villkoret.

db.Patients.aggregate (
[
{ $match : { _id: ObjectId ( '6391c61a4c91e007fb4f0228' ) } } ,
{ $projekt : {
_id: ObjectId ( '6391c61a4c91e007fb4f0227' ) ,
Ålder: ett ,
Resultat: { $eller : [
{ $gt : [ ' $Age ' , 69 ] }
] }
}
}
]
)

'Ålder' som är högre än '69' är '74' som visas i utdataskalet tillsammans med 'Resultat' som har det 'sanna' värdet.

Exempel 5: MongoDB $OR Operator åberopar villkoren

$or-operatören för MongoDB är en logisk operator. Vi kan använda denna logiska operator med den villkorliga operatorn. Operatören $or returnerar resultaten när villkoren är uppfyllda. Dessutom kan vi anropa mer än ett villkor i $or-operatorn från vilket ett måste vara sant. Här har vi en fråga om $or operator som specificeras med två olika villkor. Det första villkoret är '{Charges:{$lt: 6000}}' som returnerar dokumentet som är mindre än 'Charges'-värdet på '6000'. Villkoret {Charges:“$gt: 7000”} får dokumentet som är större än värdet för “Charges” på “7000”.

Operatören $or ger det matchade dokumentet när dessa villkor är uppfyllda. Sedan anger vi namnen på fälten som endast visas när $or-operatören ger det matchade dokumentet.

db.Patients.find ( {
$eller : [
{ Kostnader: { $lt : 6000 } } ,
{ Kostnader: { $gt : 7000 } }
]
} , {
Förnamn: ett ,
Kostnader: ett
} )

Utdatan visar endast fälten 'FirstName' och 'Charges' för de matchade dokumenten.

Exempel 6: MongoDB $OR-operatör utan argument

Alla implementerade frågor med $or-operatorn skickas med argumentvärdet. Nu definierar vi $or operatorfrågan som inte matar in något argument. När det tomma argumentet $or operatorfrågan exekveras, utvärderar den de falska resultaten. Vi ger en fråga där $or-operationen skickas med det tomma uttrycket.

db.Patients.aggregate (
[
{ $match : { _id: { $in : [ ObjectId ( '6391c61a4c91e007fb4f0228' ) ] } } } ,
{ $projekt : {
_id: ObjectId ( '6391c61a4c91e007fb4f0227' ) ,
Resultat: { $eller : [ ] } }
}
]
)

Som ett resultat av att $or-operatorn förses med ett tomt argument, anger resultaten ett falskt värde.

Exempel 7: MongoDB $OR Operator Matchar Array-värdena

Vi infogar arrayen 'Test' i dokumenten som har olika värden. Vi använder den matrisen för $or-operatören för att undersöka resultaten. Operatorn $or i följande fråga anropas i metoden find(). Operatorn $or tar arrayen 'Test' som ett uttryck. 'Test'-matrisen använder $in-operatorn för att identifiera de dokument vars fältvärden matchar 'MRI'- och 'CT'-värdena i matrisen.

db.Patients.find ( { $eller : [ { Testa: { $in : [ 'MRI' , 'CT' ] } } ] } ) .Söt ( )

Ett dokument visas på skalet när $or query-operatorn exekveras vilket visar att det hämtade dokumentet innehåller de angivna arrayvärdena.

Slutsats

Den här MongoDB-artikeln illustrerar användningen av en MongoDB $or-operatorfråga för att utföra de logiska ELLER-operationerna på en array som innehåller två eller flera uttryck samt för att hämta de dokument som matchar minst ett av uttrycken. $or-operatören frågas i MongoDB-skalet för att utföra olika operationer. Operatorn $or används i villkorsoperatorer som ett uttryck och returnerar dokumenten baserat på villkorssatserna.