MongoDB $ CMP

$ CMP er aggregeringsrørledningsoperatøren av MongoDB som brukes til sammenligning av verdiene. $ CMP-operatøren returnerer resultatene i numeriske verdier som inkluderer "1", "-1" og "0" basert på de gitte verdiene. $ CMP -operatøren returnerer “1” når den første spesifiserte verdien har en større verdi enn den andre verdien. På den annen side gir $ CMP-operatøren “-1” når den første innstilte verdien er mindre enn den andre gitte verdien. Resultatene “0” oppnås når de gitte verdiene for sammenligning i $ CMP -operatøren er like.

Hvordan sammenligner $ CMP -operatøren av MongoDB de to verdiene

Her bruker vi $ CMP -operatøren for sammenligningsformål. Vi oppretter "MyData" -samlingen som trenger dokumentene for implementering av $ CMP -operatøren. Vi lagrer de seks dokumentene samtidig i "MyData" -samlingen ved å bruke følgende InsertMany -spørring:

db.Mydata.INSERTMANY ([

"_id": 1,
"Mål": "Avstand",
"X": 5,
"Y": 3,
"Z": "Z1": 6, "Z2": 2
,

"_id": 2,
"Mål": "Speed",
"X": 10,
"Y": 10,
"Z": "Z1": 4, "Z2": 7
,

"_id": 3,
"Mål": "hastighet",
"X": 8,
"Y": 14,
"Z": "Z1": 3, "Z2": 9
,

"_id": 4,
"Mål": "Forskyvning",
"X": null,
"Y": null,
"Z": "Z1": 15, "Z2": 3
,

"_id": 5,
"Mål": "Tid",
"X": null,
"Y": 16,
"Z": "Z1": 0, "Z2": 2
,

"_id": 6,
"Mål": "Forskyvning",
"X": Isodate ("2020-12-10T05: 00: 20.112z "),
"Y": Isodate ("2023-02-06T05: 00: 20.112z "),
"Z": "Z1": 3, "Z2": 9

])

Vi henter kvitteringsalternativet som sant som indikerer at dokumentene er satt inn i den gitte samlingen av MongoDB.

Anerkjent: sant,
Sett inn: '0': 1, '1': 2, '2': 3, '3': 4, '4': 5, '5': 6

Eksempel 1: Bruke $ CMP -operatøren i MongoDB for å sammenligne med verdien

Vi bruker $ CMP -operatøren av MongoDB her for å sammenligne det spesifiserte feltet i dokumentet med en annen verdi. $ Match -operatøren er satt med "" measure ":" distanse "" -uttrykk først for å matche dokumentet for å sammenligne operasjonene. Deretter bruker vi $ prosjektoperatøren som projiserer "resultatet" -feltet for $ CMP -operatøren. $ CMP -operatøren påberopes innenfor det projiserte "resultatet" -feltet og legger inn "$ x", 5] "-uttrykket der" $ x "er et felt i det matchede dokumentet og" 5 "er verdien som skal sammenlignes med “$ X” -felt.

db.Mydata.Aggregate ([$ match: "measure": "distanse",
$ prosjekt:
Resultat: $ cmp: ["$ x", 5]]))

Resultatene fra $ CMP -operatøren viser verdien av "0" mot det anslåtte "resultatet" -feltet fordi både feltet "$ x" -verdien er "5" i dokumentet og verdien som skal sammenlignes er også "5".

[_id: 1, resultat: 0]

Eksempel 2: Bruke $ CMP -operatøren i MongoDB for å sammenligne med feltene

Vi bruker $ CMP -operatøren for å sammenligne feltet med den faste verdien. Nå oppnår vi sammenligningen med to felt av samme dokument. Vi begynner med $ prosjektoperatøren der "_id", "$ x" og "$ y" -feltene gir en verdi av "1" som vises sammen med den resulterende utgangen. Deretter definerer vi et annet "resultat" -felt i $ prosjektoperatøren der $ CMP -operatøren er ansatt med "[" $ x "," $ y "]" -uttalelsen. “$ X” og “$ y” er feltene til dokumentene som brukes av $ CMP -operatøren for å sammenligne verdiene deres.

db.Mydata.aggregat (
[
$ prosjekt:
"_id": 0,
"X": 1,
"Y": 1,
Resultat: $ cmp: ["$ x", "$ y"]


]
)

Verdien som returneres av $ CMP -operatøren for sammenligningsfelt i hvert dokument vises i det følgende. Noen resultater har verdien av "1" mot "resultat" -feltet fordi "$ x" -verdien er større enn "$ y" -verdien. Noen resultater fra $ CMP-operatøren inneholder "-1" -verdien der "$ x" -verdiene er mindre enn verdien av "$ y". Der kan vi se resultatene som har “0” -resultatene på grunn av lik verdien av både “$ x” og “$ y”.

[
X: 5, y: 3, resultat: 1,
X: 10, y: 10, resultat: 0,
X: 8, y: 14, resultat: -1,
X: null, y: null, resultat: 0,
X: null, y: 16, resultat: -1,
X: Isodate ("2020-12-10T05: 00: 20.112Z "), Y: Isodate (" 2023-02-06T05: 00: 20.112Z "),
Resultat: -1
]

Eksempel 3: Bruke $ CMP -operatøren i MongoDB for å sammenligne med de innebygde feltene

Deretter distribuerer vi $ CMP -operatøren som skal sammenlignes over de innebygde feltene i dokumentet. Her finner vi ut dokumentet hvis "mål" -feltet lagrer "hastighet" -verdien. Når dokumentet er matchet av $ Match -operatøren, sammenligner $ CMP -operatøren verdien. Vi har "Resultat" -feltet inne i $ Prosjektoperatøren som er satt med $ CMP -operatøren. $ CMP -operatøren inneholder de to innebygde feltene, “Z1” og “Z2”, av “Z” -feltet som skal sammenlignes.

db.Mydata.Aggregate ([$ match: "measure": "speed",
$ prosjekt: Resultat:
$ cmp: ["$ z.Z1 "," $ z.z2 "]])

Den returnerte verdien er "-1" mot alternativet "Resultat" fra $ CMP-operatøren siden den innebygde "$ z.Z1 ”-feltet har en mindre verdi enn $ z.Z2 -verdi.

[_id: 2, resultat: -1]

Eksempel 4: Bruke $ CMP -operatøren i MongoDB for å sammenligne med nullverdiene

$ CMP -operatøren sammenligner også nullverdiene i MongoDB. "Null" er spesifisert som verdien anses som strengverdien. Her sammenligner vi feltene i dokumentet som har nullverdier. Vi setter $ Match -operatøren som samsvarer med dokumentet med "_id" -feltet hvis verdi er "4". Etter dette definerer vi “_id”, “mål”, “x” og “y” -feltene med “1” for inkludering av disse feltene. Deretter brukes $ CMP -operatøren av $ Prosjektoperatøren "Res" -feltet. $ CMP -operatøren her sammenligner verdiene til “$ x” og “$ y” -feltene som er lagret i dokumentet til “_id: 4”.

db.Mydata.aggregat (
[
$ match: "_id": 4,
$ prosjekt:

"_id": 1,
"X": 1,
"Y": 1,
Resultat: $ cmp: ["$ x", "$ y"]


]
)

“Res” har utgangsverdien til “0” fordi når verdiene blir sammenlignet av $ CMP -operatøren, inneholder de null. Hvis en av verdiene er null og den andre har et tall, sammenligner $ CMP -operatøren dem annerledes som er diskutert i følgende eksempel:

[_id: 4, x: null, y: null, resultat: 0]

Eksempel 5: Bruke $ CMP -operatøren i MongoDB for å sammenligne de forskjellige typene

$ CMP -operatøren sammenligner verdien så vel som de forskjellige typene i henhold til den oppgitte sammenligningsrekkefølgen. Vi har dokumentene i vår "MyData" -samling som inneholder de forskjellige typer verdier. $ CMP -operatøren kan sammenligne dem og generere resultatet i henhold til typen verdi. Vi har et spørsmål der $ Match -operatøren finner dokumentene med "_id" -feltet. "_Id" -feltet satt inne i $ Match -operatøren som et uttrykk kalles videre $ NIN -operatøren. $ NIN -operatøren av MongoDB samsvarer bare med dokumentet hvis “1, 2, 3” -verdier ikke er like. Etter det påkaller vi $ CMP -operatøren som sammenligner de matchede dokumentfeltene, “$ x” og “$ y”, med forskjellige typeverdier.

db.Mydata.aggregat (
[
$ match: "_id": $ nin: [1, 2, 3],
$ prosjekt:

"_id": 1,
"Mål": 1,
"X": 1,
"Y": 1,
Res: $ cmp: ["$ x", "$ y"]


]
)

Vi kan se verdiene til de sammenlignede "x" og "y" -feltene i utgangen og deres resulterende verdier som genereres av $ CMP -operatøren. Hvert matchet dokument returnerer de forskjellige sammenlignet verdiene.

[
[
_id: 4, mål: 'Forskyvning', x: null, y: null, res: 0,
_id: 5, måle: 'tid', x: null, y: 16, res: -1,

_id: 6,
Mål: 'Forskyvning',
X: Isodate ("2020-12-10T05: 00: 20.112Z "),
Y: Isodate ("2023-02-06T05: 00: 20.112Z "),
Res: -1

]

Konklusjon

Denne guiden utforsket MongoDB $ CMP -operatøren for å sammenligne verdiene. Her diskuterte vi $ CMP -operatøren med eksempler. Vi sammenlignet først feltet med den spesifiserte verdien ved å bruke $ CMP -operatøren. Deretter sammenlignet vi de to forskjellige feltene og de innebygde feltene av $ CMP -operatøren. $ CMP -operatøren brukes også til å sammenligne nullverdiene. Til slutt har vi en bruk av $ CMP -operatøren for å sammenligne verdien av forskjellige typer.