MongoDB $ filteroperatør

MongoDB $ filteroperatøren henter en undergruppe av en matrise som er basert på et forhåndsdefinert kriterium. Med et annet ord gir $ filteroperatøren en matrise som bare inneholder elementene som tilfredsstiller kriteriene i den rekkefølgen de ble spesifisert. $ Filteroperatøren har parametere som inkluderer "input", "som" og "cond". "Input" -argumentet er uttrykket som tar matrisefeltet for å filtrere det spesifiserte dokumentet. Neste er det valgfrie argumentet "AS" som tar variabeltnavnet på inngangsarrayelementet for å få tilgang til hvert element. Deretter avgjør "cond" -argumentet om elementet er inkludert i den resulterende matrisen.

Hvordan $ filteroperatøren brukes i MongoDB

$ Filteroperatøren av MongoDB brukes til å filtrere ut matrisedataene i henhold til den gitte betingede uttalelsen. Bruken av $ filteroperatøren fungerer på dokumentene som er satt inn i den spesifiserte samlingen av MongoDB. Her distribuerer vi InsertMany () spørring av MongoDB for å sette inn tre dokumenter i "Cricket" -samlingen. Hver plate inneholder tre felt - “_id”, “Player” og “RunSrecord” - som er satt som en matrise. Dokumentinnsatsformatet er representert i følgende:

db.Siriss.InsertMany ([
"_id": 1,
"Player": "Ravi",
"RunSrecord": [100, 50, 70],
"Fyrstikker" :

"Match1": "WorldCup",
"År": "2000"

,

"_id": 2,
"Player": "Andrew",
"RunSrecord": [150, 90, 55]
,

"_id": 3,
"Player": "Smith",
"RunSrecord": [80, 99, 45]
,

"_id": 4,
"Spiller": "Alex",
"RunSrecord": []
])

Dokumentene i "Cricket" -samlingen blir sett inn som vist i følgende utdata:

anerkjent: True, InsertedIds: '0': 1, '1': 2, '2': 3, '3': 4

Eksempel 1: MongoDB bruker $ filteroperatøren i MongoDB

Den grunnleggende $ filteroperatøren av MongoDB -eksemplet er gitt i denne delen. Vi setter et spørsmål der $ prosjektoperatøren kalles i den samlede metoden. Vi påkaller $ filteroperatøren i $ prosjektoperatøren. $ Filteroperatøren er ytterligere spesifisert med sin parameter. "Input" -parameteren er satt med navnet på "$ runsrecord" -feltet med "$" -tegnet for å hente ut dataene fra det. Deretter bruker vi "AS" -parameteren for å gi tittelen til returvariabelen, "RunSrecord". Denne variabelen blir deretter referert til ved bruk av "cond" -parameteren med dobbelt dollarskiltet, "$$". Neste er parameteren "Cond" der uttrykket tildeles som "$ gt: [" $$ RunSrecord ", 50]". Forholdene innebærer at "$ gt" -operatøren får matriseelementet som er større enn verdien av "50" i "RunSrecord" -array -feltet.

db.Siriss.aggregat ([

$ prosjekt:
Highruns:
$ filter:
Input: "$ runsrecord",
AS: "RunSrecord",
cond: $ gt: ["$$ runsrecord", 50]




])

Resultatene av følgende $ filter -spørring returnerer bare disse verdiene fra matrisen som er større "50". Verdien som er mindre enn "50" blir ignorert av $ filteroperatøren.

[
_id: 1, Highruns: [100, 70],
_id: 2, Highruns: [150, 90, 55],
_id: 3, Highruns: [80, 99],
_id: 4, Highruns: []
]

Eksempel 2: MongoDB bruker $ filteroperatøren for å filtrere feltet som ikke er eksistens

Nå tar vi en sak der $ filteroperatøren blir brukt på feltet som ikke er til stede i noen innsamlingsdokumenter. Her har vi et spørsmål der $ filteroperatøren er ansatt med parametrene. Inngangsparameteren er angitt med "$ lønn" -feltet for å filtrere dokumentet. Deretter bruker vi "AS" valgfri parameter som også er gitt med variabelnavnet "lønn", som brukes i inngangsarrayen som et element. Etter dette har vi et betinget uttrykk i "cond" -parameteren til $ filteret. $ Filteroperatøren filtrerer ut array -elementet basert på den spesifiserte tilstanden som er “$ GTE: [“ $$ Lønn ”, 6000]”.

db.Siriss.aggregat ([

$ match: _id: $ in: [2]
,

$ prosjekt:
Highruns:
$ filter:
Input: "$ Lønn",
som: "Lønn",
cond: $ gte: ["$$ lønn", 6000]




])

Som vi vet, er det oppgitte "lønn" -feltet ikke til stede i dokumentet hvis "_id" er "2", så utgangen fra den forrige spørringen til $ filteroperatøren gir en nullverdi.

[_id: 2, highruns: null]

Eksempel 3: MongoDB bruker $ filteroperatøren for å filtrere den tomme matrisen

Neste er scenariet der $ filteret brukes over den tomme matrisen. $ Filteroperatøren returnerer et tomt matrise -sett hvis et av dokumentene i samlingen har en tom matrise. Vi har følgende $ filteroperatørforespørsel. Vi har $ Match -operatøren først der "_id: $ in: [4]" -uttrykket er gitt for å være fornøyd. Når $ i operatøren finner verdien av "4" mot "_id" -feltet, fortsetter den neste operatøren. Deretter har vi en $ filteroperatør som filtrerer utvalget av elementer basert på den gitte tilstanden som er "$ gt: [" $$ runsrecord ", 45]".

db.Siriss.aggregat ([

$ match: _id: $ in: [4]
,

$ prosjekt:
Highruns:
$ filter:
Input: "$ runsrecord",
AS: "RunSrecord",
cond: $ gt: ["$$ RunSrecord", 45]




])

"_Id: 4" har "runsrecord" -feltet som er tomt. Det er grunnen til at når spørringen blir utført, sender den ut den tomme matrisen som følger:

[_id: 4, Highruns: []]

Eksempel 4: MongoDB bruker $ filteroperatøren i MongoDB med det valgfrie variabelenavnet

Vi satte en tittel på variabelen i foregående tilfeller ved å bruke "AS" -argumentet. Hvis "AS" -argumentet ikke er angitt med noe variabelnavn, er "$ this" -variabelen satt som standard av MongoDB. La oss ha spørringseksemplet for denne uttalelsen. Vi samsvarer med dokumentet ved å ringe $ Match -operatøren der vi har et "_id" -felt der verdiene er angitt. Vi tildeler en $ filteroperatør til "$ prosjekt" -operatøren der $ filteroperatøren kalles med parametrene. Her har vi en "input" -parameter med navnet "$ runsrecord" -feltet. Deretter bruker vi "cond" -parameteren med den spesifiserte tilstanden. Tilstanden er satt som "cond: $ lt: [" $$ this ", 80]". Denne gangen brukes $ LT -operatøren til å finne verdien som er mindre enn verdien av "80". Merk at i stedet for et "$$ RunSrecord" -variabeltnavn, bruker vi “$$ this” standard variabelnavn her som ikke påvirker den resulterende utgangen.

db.Siriss.aggregat ([

$ match: _id: $ in: [1, 2, 3, 4]
,

$ prosjekt:
Highruns:
$ filter:
Input: "$ runsrecord",
cond: $ lt: ["$$ this", 80]




])

$ Filteroperatøren filtrerer den spesifiserte matrisen med $ denne variabelen på samme måte som med den spesifiserte variabelen.

[
_id: 1, Highruns: [50, 70],
_id: 2, Highruns: [55],
_id: 3, Highruns: [45],
_id: 4, Highruns: []
]

Eksempel 5: MongoDB bruker $ filteroperatøren for å filtrere med flere forhold

Vi kan gi mer enn én tilstand til $ filteroperatøren for å filtrere ut bare dokumentene som samsvarer med den gitte tilstanden. Her definerer vi $ filteroperatøren der $ og operatøren brukes i "cond" -parameteren. $ Og operatøren er satt med flere forhold som “$ gte: [“ $$ RunsRecord ”, 45]” og “$ lte: [“ $$ RunSrecord ”, 99]”. $ Og operatøren brukes som krever begge forholdene som sanne.

db.Siriss.aggregat ([

$ prosjekt:
Highruns:
$ filter:
Input: "$ runsrecord",
AS: "RunSrecord",
cond: $ og: [
$ gte: ["$$ RunSrecord", 45],
$ lte: ["$$ RunSrecord", 99]
]




])

Med flere forhold filtrerer vi ut det matchede dokumentet i følgende:

[
_id: 1, Highruns: [50, 70],
_id: 2, Highruns: [90, 55],
_id: 3, Highruns: [80, 99, 45],
_id: 4, Highruns: []
]

Konklusjon

Vi utforsket denne artikkelen som handler om $ filteroperatøren av MongoDB. Her ga vi implementeringen av MongoDB -skriptet til $ filteroperatøren for å filtrere de spesifiserte dataene. Vi demonstrerte først den grunnleggende bruken av $ filteroperatøren. Deretter brukte vi $ filteroperatøren over dokumentet hvis felt ikke er lagt til i dokumentet. Det tomme array -feltet er også distribuert på $ filteroperatøren som henter den tomme matrisen. Videre brukes $ filteroperatøren med $ denne variabelen som er standardvariabelen.