MongoDB $ oppslag

Dokumentene sendes til rørledningen med flere operatører som $ Match og $ eksisterer for å samle dataene. Lookup -operatøren $ er en av operatørene av aggregeringsrørledningen som tillater dataene å bli knyttet til en input -samling. MongoDB -oppslagsoperatøren bruker venstre ytre sammenføyningsoperasjon for å kombinere dataene fra ett dokument til et annet. Med enkle ord lar $ -oppslagsmetoden oss enkelt "bli med" de forskjellige samlingene ved å gi resultatene som inkluderer feltene fra alle gitte samlinger. Den største fordelen med MongoDB $ oppslagsoperatøren er at den håndterer dataene på serveren som er mye raskere enn å kjøre flere DB -spørsmål og analysere resultatene fra klientsiden. Vi vil diskutere om MongoDB $ oppslagsoperasjonsprinsippet i denne artikkelen.

Hvordan fungerer MongoDB $ oppslagsoperatøren?

Som nevnt gjør $ -oppslagsoperatøren i MongoDB oss i stand til å kombinere dokumentene fra forskjellige samlinger i samme database. $ Lookup-operatøren håndterer de ikke-relaterte subkranene så vel som likestillingskampene. Hver kamp med $ Lookup -operatøren har en annen struktur som vi vil se på med eksemplet implementering. Vi etablerer "kandidater" -samlingen som vi bruker i vårt eksempel for å utføre $ Lookup Operator. Her setter vi inn to dokumenter med InsertMany () -metoden som inneholder følgende felt:

db.Kandidater.InsertMany (
[

Kandidat_id: 01,
"Navn": "Andrew",
"RollNumber": 099912,
"Test": "MBBS",
"AcademicStatus": ["Schoolmarks": "A", "CollegeGrades": "B"],
"Status": "Kvalifisert"
,

Kandidat_id: 02,
"Navn": "Stella",
"RollNumber": 0012123,
"Test": "BDS",
"AcademicStatus": ["SchoolGrades": "A+", "CollegeGrades": "A"],
"Status": "Kvalifisert"

]
);

De innsatte spørringsresultatene skal vises slik i MongoDB -samlingen:

Deretter konstruerer vi en annen samling som har tittelen “CandidateInfo”. Vi setter inn dokumentet i denne samlingen ved å bruke InsertMany () -metoden.

db.Kandidatinfo.InsertMany (
[

"Kandidat_navn": "Andrew",
"Alder": 27,
"Kjønn Mann",
"Test": "MBBS",
"City": "California"
,

"Kandidat_navn": "Stella",
"Alder": 25,
"Kjønn kvinnelig",
"Test": "BDS",
"City": "Houston"

]
);

Resultatene av å legge til dokumentet i samlingen “CandidateInfo” indikerer at dokumentene er riktig satt inn. Nå kan vi bruke begge disse samlingene for å koble til $ Lookup -operatøren.

Eksempel 1: Bruke MongoDB $ oppslagsoperatør for likestillingskampen

Lookup -operatøren av MongoDB er ansatt i dette eksemplet for å slå sammen operasjonene på en nøkkel fra den gitte databasen og den kombinerte databasen. Her spesifiserer vi likestillingsmatch -spørringen på "kandidat" -samlingen med Aggregate () -metoden. Aggregate () -metoden implementeres videre med $ Lookup -operatøren. Lookup -operatøren inneholder forskjellige begrensninger som alle er pålagt å kombinere den gitte samlingen.

Den første utplasserte begrensningen er "fra" -begrensningen som er tildelt med et navn på samlingen, "CandidateInfo", som skal sammenføyes. Deretter setter vi "Localfield" -begrensningen der navnet på "Navn" -feltet fra dokumentet til den gitte samlingen er tildelt. Localfield er definert som feltet i den lokale samlingen som skal kombineres. Deretter definerer vi Foreignfield -attributtet som er spesifisert med "Candidate_name" -feltet fra "CandidateInfo" -samlingen for å slå sammen med "Kandidat" -samlingen. Etter det brukes "AS" -begrensningen for å generere utvalget av de matchede resultatene fra $ Lookup -operatøren.

db.Kandidater.aggregat ([
$ oppslag:

Fra: "CandidateInfo",
Localfield: "Navn",
Foreignfield: "Kandidatnavn",
som: "CandidateInfo"


])

Produksjonen fra $ Lookup -spørringen kombinerer kampene fra "CandidateInfo" -samlingen til "Kandidater" -samlingen ved å bruke feltverdiene "Navn" og "Candidate_name" i henholdsvis "kandidater" og "CandidateInfo" -samlinger, henholdsvis.

Eksempel 2: Bruke MongoDB $ oppslagsoperatør med utvalgskriteriene

Likestillingskampen til samlingene oppnås i forrige eksempel. Nå bruker vi $ Lookup -operatøren med den betingede operatøren for å bli med på samlingene. Vi gir en $ Lookup Operator -spørring i aggregeringsmetoden på "CandidateInfo" -samlingen. Inne.

Først definerer vi "fra" -begrensningen som er definert med en annen samling som er "kandidater". Merk at vi bruker "Let" og "rørledningen" -begrensningene etter "fra" -begrensningen i stedet for Localfield og Foreignfield. "Let" -begrensningen er erklært med "C_AGE" -variabelen som er tildelt med et "$ alder" -felt. "C_TEST" -variabelen er erklært som holder feltnavnet "$ test". Vi erklærer disse variablene for å hente feltene fra dokumentene i den kombinerte samlingen som sendes inn i rørledningen.

Etter det oppretter vi “rørlednings” -attributtet der betingede operatører er inndata. Bruken av rørledningsbegrensningen er å kjøre sammenføyningsoperasjonen over den gitte samlingen. Deretter er rørledningen assosiert med $ Match -trinnet som ytterligere setter $ expr -trinnet. $ Expr -stadiet sammenligner feltene ved å bruke inngangsvariablene i "la" attributtet. $ Expr -trinnet er erklært med $ og operatøren der vi gir “$ lt: [“ $ age ”,“ $$ c_age ”]” og $ eq: [“$$ c_test”, “$ test” ] uttrykkene. Vi kan sammenligne samlingen bare på denne måten for $ oppslagsoperatøren. Uttrykkene er spesifisert med det doble dollarskiltet "$$" for å referere til variablene som er definert i "Let" -begrensningen, og enkeltdollarskiltet "$" indikerer et utenlandsk felt. Rørledningsattributtet blir deretter lukket. Til slutt definerer vi “AS” -attributtet til $ Lookup -operatøren for å gi "kandidat" -samlingen for å kombinere med "CandidateInfo" -samlingen.

db.Kandidatinfo.aggregat ([
$ oppslag:

Fra: "Kandidat",
La: c_age: "$ alder", c_test: "$ test",
Rørledning: [
$ match:
$ expr:
$ og:
[
$ lt: ["$ alder", "$$ c_age"],
$ eq: ["$$ c_test", "$ test"]
]



],
som: "Kandidater"


]).ganske();

Følgende utgang oppnås ved å utføre rørledningen på $ Lookup Operator med utvalgskriteriene:

Eksempel 3: Bruke MongoDB $ oppslagsoperatøren med $ MergeObject -operatøren

$ Merge -objektene brukes til å endre dokumentene i den gitte samlingen som avhenger av begrensningene som er satt i $ oppslag OEPRATOR. Her satte vi først $ Lookup -operatøren med begrensningene. Deretter kaller vi $ MergeObject som også setter sin begrensning for å utføre den modifiserte samlingen som returneres fra $ Lookup -operatøren. I den følgende spørringen brukes $ Lookup -operatøren til å bli med i "kandidat" -samlingen fra "CandidateInfo" ved å bruke Localfield og Foreignfield som "test". Deretter bruker vi $ erstatningsstadiet som påkaller $ MergeObjects for å kombinere dokumenter fra "kandidatene" og "kandidatinfo" -samlingene.

db.Kandidater.aggregat ([

$ oppslag:
Fra: "CandidateInfo",
Localfield: "Test",
Foreignfield: "Test",
som: "Fromcandi"

,

$ erstatning: newRoot: $ MergeObjects: [$ arrayelemat: ["$ fromcandi", 0], "$$ root"]
,
$ prosjekt: "Fromcandi": 0
])

Etter å ha spurt denne $ oppslagsoperasjonen med $ MergeObject, har vi følgende resultater:

Konklusjon

$ Oppslagsoperatøren hjelper til med å identifisere passende data og anskaffe de ønskede resultatene. Vi implementerte tre eksempler ved å bruke $ Lookup -operatøren. I det første eksemplet brukte vi $ Lookup -operatøren for likestillingsmatching. Deretter har vi et eksempel der forholdene brukes til å utføre oppslagsoperatørresultatene. Vi brukte også $ MergeObjects -trinnet med $ Lookup -operatøren for å endre dokumentene.