MongoDB og operatør

MongoDB $ og operatøren fungerer som funksjonaliteten til logisk og operasjoner på ett eller flere uttrykk i en matrise. $ Og operatøren kan distribueres innen metoder som Find (), Update (), og så videre, basert på kravene til brukeren. $ Og operatøren gir sanne hvis alle spesifiserte uttrykk evaluerer de sanne resultatene. Når $ og operatøren har et uttrykk som evaluerer å være usant, avslutter det å evaluere de gjenværende uttrykk. Dette er kjent som kortslutningsevaluering. I tillegg blir null-, null- og udefinerte innganger evaluert som falske av $ og operatøren.

Hvordan bruke $ og operatør i MongoDB?

Syntaksen til og operatøren er grei i MongoDB. “$ Og: [exp1, exp2,…]” brukes med samlingsnavnet til MongoDB. Merk at $ og operatøren tar to eller mer enn to uttrykk og samsvarer med dokumentene som tilfredsstiller alle disse uttrykkene. Samlingen kreves som vi skal bruke den logiske og operatøren. For dette har vi laget MongoDB -samlingen “PrimaryStudents” der dokumentene settes inn med InsertMany () -metoden.

db.Primærstudenter.INSERTMANY ([

"Studentname": "Kyle",
"Kjønn kvinnelig",
"Alder": 9,
"Klasse": "KG",
"AdmissionYear": 2022,
"Prosent": 99.64,

"Studentname": "Carle",
"Kjønn Mann",
"Alder": 8,
"Klasse": "KG",
"AdmissionYear": 2018,
"Prosent": 91.94,

"Studentname": "Walker",
"Kjønn Mann",
"Alder": 11,
"Klasse": "en",
"AdmissionYear": 2021,
"Prosent": 95.56,

"Studentname": "Bella",
"Kjønn kvinnelig",
"Alder": 6,
"Klasse": "PG",
"AdmissionYear": 2022,
"Prosent": 93.12,

"Studentname": "Alex",
"Kjønn Mann",
"Alder": 12,
"Klasse": "To",
"AdmissionYear": 2021,
"Prosent": 98.96])

Vi har fem dokumenter i "PrimaryStudents" -samlingen som er oppført med innsatsen som vist i følgende skallbilde:

Eksempel nr. 1: MongoDB $ og operatør og $ eller operatørforskjell.

$ Og operatør og $ eller operatør regnes begge som de logiske operatørene av MongoDB. Disse operatørene brukes til å matche det nødvendige dokumentet fra den gitte samlingen. $ Og operatøren av MongoDB trenger alle uttrykkene som skal evalueres som "sann". Hvis noen av de spesifiserte uttrykkene i $ og operatøren returnerer falske resultater, slutter $ og operatøren å evaluere andre uttrykk. Her har vi en enkel $- og operatørforespørsel som brukes på "PrimaryStudents" -samlingen. $ Og operatøren er distribuert inne i Find () -metoden for å finne det matchede dokumentet som oppfylte de spesifiserte uttrykkene. $ Og operatøren er utstyrt med de to uttrykkene: “Studentname:“ Bella ”” og “Age: 12”. $ Og operatøren er pålagt å matche dokumentet hvis "studentnavn" er "bella" og "alder" er "12". Det første uttrykket blir evaluert først når dette gir den sanne verdien, og deretter evaluerer operatøren det andre uttrykket.

db.Primærstudenter.finn ($ og: [studentname: "Bella", Age: 12])

Vi har oppnådd resultater som er basert på begge uttrykkene som har sanne verdier. Følgende dokument har “Studentname: Bella” og “Age: 12”:

Vurder nå eksemplet på spørringen til $ eller operatøren. Vi har en $ eller operatør som tar uttrykkene “Studentname:“ Walker ”” og “Age: 6”. $ Eller operatøren søkte etter studentnavnet “Walker” og uttrykket er usant, så søkte det etter neste uttrykk som er alderen skal være “6” i dokumentet. $ Eller operatøren oppretter resultater basert på hvilke av to uttrykk som returnerer sanne.

db.Primærstudenter.finn ($ eller: [studentname: "walker", alder: 6])

De to dokumentene blir hentet fra $ eller operatøren fordi begge uttrykkene har de samme resultatene, men dokumentene er forskjellige. Hvis vi har ett falskt uttrykk, vil bare ett dokument oppnås i henhold til kravet til $ eller operatøren.

Eksempel nr. 2: MongoDB $ og operatør for samme felt.

Den generelle representasjonen av $ og operatør og dens evaluering i MongoDB er demonstrert i spørringen ovenfor. Nå bruker vi $ og operatøren for de samme feltene for å skaffe seg det matchede dokumentet. $ Og operatøren er spesifisert med uttrykket “class: $ eq:“ kg ”, class: $ eksisterer: true” der “klassen” er feltnavnet som bruker lik “$ EQ ”operatør for å finne verdien“ kg ”fra dokumentene. Deretter tildeles feltet "klasse" en $ eksisterende operatør som er satt med det "sanne" nøkkelordet for å finne alle eksisterende dokumenter som inneholder den angitte verdien av feltet.

db.Primærstudenter.finn ($ og: [class: $ eq: "kg", class: $ eksisterer: true]).ganske()

Dette er følgende eksisterende dokumenter som er returnert av $ og operatøren som har "klasse" -verdien "kg":

Eksempel nr. 3: MongoDB $ og operatør for flere felt.

Som vi har nevnt tidligere, kan $ og operatør også sendes med flere uttrykk. $ Og operatøren evaluerer disse uttrykkene basert på sanne resultater. Her har vi et spørsmål der vi har gitt uttrykk for $ og operatør: “$ og: [“ klasse ”: $ ne:“ tre ”, “ alder ”: $ gte: 8, “Prosent”: $ LT: 98.96 ”. Uttrykket ““ klasse ”: $ ne:“ tre ”” finner en verdi som ikke er lik “tre” som “$ ne” -operatøren brukes. Deretter har vi et uttrykk “Age”: $ gte: 8 som finner dokumentene hvis “alder” -verdien er større enn lik “8”. Etter det, det tredje uttrykket “Prosent”: $ LT: 98.96 evaluerer for prosentandelen som er mindre enn “98.96 ”. $ Og operatøren tilfredsstilte alle disse uttrykkene og returnerte de forventede dokumentene.

db.Primærstudenter.finn ("$ og": ["class": $ ne: "tre", "alder": $ gte: 8, "prosent": $ lt: 98.96])

Dokumentene som vises nedenfor er dokumentene som er innhentet etter tilfredsstillende $ og operasjon.

Eksempel 4: MongoDB $ og operatør for flere forhold.

Her har vi brukt $ eller operatøren som uttrykk for $ og operatøren. Først vil vi få resultatene fra $ eller operatøren som blir evaluert av $ og operatøren for å gi det spesifiserte dokumentet. Her har vi distribuert $ og operatøren som har det første uttrykket $ eller: [kjønn: “hann”, alder: 9]. $ Eller operatøren evaluerte resultatene for feltet "kjønn" hvis verdi er "mann" og "alder" er "9". Hvis en av forholdene er sant, er det sant. Etter det har vi andre uttrykket “$ eller: [“ Prosent ”: 95.56, “AdmissionYear”: 2019] ”evaluerer $ eller operatøren for de dokumentene hvis“ prosentvis ”er“ 95.56 ”og“ AdmissionYear ”er“ 2019 ”. Både disse $ eller operatørresultatene er uttrykkene for $ og operatøren som deretter blir evaluert i henhold til den nødvendige tilstanden.

db.Primærstudenter.finn ($ og: [$ eller: [kjønn: "mann", alder: 9], $ eller: ["Prosent": 95.56, "AdmissionYear": 2019]]).ganske()

Både $ eller uttrykk har ett falskt og ett sant resultat som anses som sant i henhold til kravet til $ eller operatør. Når begge uttrykkene blir sanne, returnerer $ og operatøren følgende dokument:

Eksempel 5: MongoDB $ og operatør for aggregering.

Aggregeringsmetoden bruker også $ og operatør for å utføre den logiske $ og operatøren. Her har vi distribuert $ og operatøren innen Aggregate () -metoden til MongoDB. Vi har begynt spørringen ved å bruke Aggregate () -metoden som deretter er spesifisert med $ prosjektoperatøren. $ Prosjektoperatøren brukes til å spesifisere det eneste feltet vi ønsker å hente fra dokumentene. Vi har satt "studentnavnet" og "prosentvise" -feltet som skal vises. Deretter har vi $ og operatøren som “[$ gt: [“ $ prosent ”, 90.00], $ lt: [“$ prosent”, 95.00]] ”uttrykk som skal evalueres. $ Og operatøren får dokumentene som har "prosentandelen" større enn "90.00 ”og“ prosentvis ”mindre enn“ 95.00 ”. De to forskjellige forholdene brukes på samme felt "prosent".

db.Primærstudenter.Aggregate ([$ Project: StudentName: 1, Prosent: 1, Resultat: $ og: [$ gt: ["$ prosent", 90.00], $ lt: ["$ prosent", 95.00]]])

Resultatene på $ og samlet operatør er oppført i følgende dokument som oppfyller kriteriene:

Konklusjon

Vi har utforsket funksjonaliteten til $ og operatøren i MongoDB med denne spesielle guiden. Vi har forklart representasjonen av $ og operatøren med spørringseksemplene som kan kjøres i MongoDB. $ Og operatøren blir også evaluert for flere betingede uttrykk. Husk den tangen om at å gi et komma-separert sett med uttrykk fremmer en implisitt og operatør i MongoDB.