MongoDB $ strcasecmp

Mens vi gjør en sammenligning på forskjellige språk, har vi en tendens til å bruke sammenligningsoperatører. Sammenligningen kan være saksfølsom eller ufølsom i henhold til valg av en bruker. Akkurat som andre utviklingsmiljøer, har MongoDB sin sammenligningsoperatører, og en av disse operatørene er "StrcaseCMP" -operatøren. MongoDB strcaseCMP-operatøren sammenligner to strengverdier på en case-ufølsom måte I.e., Ignorer strengfeltet og søk. StrcaseCMP -operatøren returnerer 0 hvis begge strengene er like, 1 hvis den første verdien er større enn den andre, og -1 hvis den første verdien er mindre enn den andre verdien. Operatøren kan brukes i en MongoDB -spørring for å filtrere dokumenter basert på strengverdier.

Lage samling

Begynn med opprettelsen av en ny databasesamling i databasebanken din. Kommandoen vedlagt nedenfor oppretter en ny samling kalt “Data” i vår MongoDB -database “Test”. Responsen fra OK: 1 indikerer at samlingen ble opprettet og kan brukes videre.

Test> DB.CreateCollection ("Data")
OK: 1

Sett inn poster til samling

I starten av å lage en samling, må den være tom, da vi ikke har lagt til noen dokumenter til den ennå. For å utføre STRCASECMP -operatøren på en "data" -samling, bør den ha dokumenter. Derfor vil vi bruke MongoDB InsertMany -funksjonen for å legge til mange poster i en samling som heter "Data" på en gang. Dokumentene som blir satt inn er i format av nøkkelverdipar, med nøkler “tittel” og “Desc” og deres respektive verdier. Verdiene som blir satt inn inkluderer "John", "John", "Idk" og "Lisa" for "tittel" -tasten og "en tilfeldig fyr", "god gutt", "idontknow" og "Enginner" for " Desc ”-tast. Kommandoen er å legge til 4 nye dokumenter. Utgangen viser den "anerkjente" som en boolsk verdi, som er satt til sann, noe som indikerer at spørringen ble anerkjent og utført av MongoDB -serveren vellykket.

Test> DB.Data.InsertMany ([tittel: "John", desc: "A Random Guy", Tittel: "John", Desc: "Good Boy", Tittel: "Idk", Desc: "Idontnow", tittel : "Lisa", Desc: "Enginnerer"])

Anerkjent: sant,
innsats:
'0': ObjectId ("63c90d6a42844a817c33167c"),
'1': ObjectId ("63c90d6a42844a817c33167d"),
'2': ObjectId ("63c90d6a42844a817c33167e"),
'3': ObjectId ("63c90d6a42844a817c33167f")

Vis samlingsoppføringer

Etter å ha satt inn totalt 4 poster i "Data" -samlingen av "Test" -databasen, bør vi bekrefte dokumentene minst en gang. Derfor må vi vise de innsatte postene i MongoDB -skallet for visning. Kommandoen for å se postene er vedlagt nedenfor. Ved å bruke MongoDB Find () -metoden, hentet vi alle dokumenter fra "Data" -samlingen. Det tomme objektet bestått som et argument til Find () -metoden betyr at ingen filtreringstilstand blir brukt og alle dokumenter i samlingen vil bli returnert. Utgangen fra denne kommandoen er en rekke dokumenter, hver og en som inneholder _id-, tittelen og DESC -felt og deres respektive verdier, som ble lagt til tidligere i samlingen. Utgangen bekrefter at dokumentene er til stede i samlingen og kan hentes for videre behandling.

Test> DB.Data.finne()
[_id: ObjectId ("63c90d6a42844a817c33167c"), tittel: 'John', desc: 'en tilfeldig fyr',
_id: ObjectId ("63c90d6a42844a817c33167d"), tittel: 'John', desc: 'god gutt',
°,
_id: ObjectId ("63c90d6a42844a817c33167f"), tittel: 'lisa', desc: 'Enginner']

Eksempel # 01:

I vår første illustrasjon av MongoDB, vil vi bruke StrCaseCMP-operatøren for å utføre en sammenligning mellom to strengverdier: case-ufølsom sammenligning. For dette skal vi kjøre spørringen som vises nedenfor i MongoDB -skallet som bruker MongoDBs samlede funksjon for å utføre en serie operasjoner på en samling som heter “Data”. Den første operasjonen er et $ prosjektfase, som endrer dokumentene i samlingen ved å legge til eller fjerne felt. I dette tilfellet kommer $ prosjektstadiet til å vise alle postene til feltet "tittel" sammen med å legge til et nytt felt som heter "Resultat" til hvert dokument, som er resultatet av å sammenligne verdien av "tittel" -feltet til Strengen "IDK" ved hjelp av $ strcaseCMP -operatøren.

Sammenligningen er case-ufølsom, noe som betyr at “John” og “John” vil bli ansett som like. Det nye "Resultat" -feltet viser utdataene fra sammenligningen av "tittel" -feltet til "IDK". 0 på den tredje posten viser at strengen "ID" er lik "idk" -strengen i "tittel" -feltet mens resten er 1.

Test> DB.Data.Aggregate ([$ Project: Tittel: 1, Resultat: $ strcasecmp: ["$ tittel", "idk"]]))
[_id: ObjectId ("63c90d6a42844a817c33167c"), tittel: 'John', resultat: 1,
_id: ObjectId ("63c90d6a42844a817c33167d"), tittel: 'John', resultat: 1,
_id: ObjectId ("63c90d6a42844a817c33167e"), tittel: 'idk', resultat: 0,
_id: ObjectId ("63c90d6a42844a817c33167f"), tittel: 'lisa', resultat: 1]

Eksempel # 02:

La oss få en ny illustrasjon av å sammenligne strenger på en følsom måte i MongoDB-databasen. Denne gangen bruker koden vi har brukt den samme aggregatfunksjonen for å utføre en sammenligning på "tittel" -feltet. $ Prosjektfasen oppretter et nytt felt med samme navn: "Resultat" som lagrer resultatet av sammenligningen. Til sammenligning bruker vi den samme $ strcasecmp -operatøren. $ Strcasecmp -operatøren sendes med to argumenter: “$ tittel”, som er verdien av "tittel" -feltet i hvert dokument, og "John", som er strengen som brukes som sammenligningsverdi. I dette eksemplet har det første dokumentet et "tittel" -felt av 'John', som er lik "John", så resultatet er 0.

Det andre dokumentet har et "tittel" -felt av 'John', som også er lik "John", men i store bokstaver. Så "resultatet" er også 0. Det tredje dokumentet har et "tittel" -felt av 'idk', som er mindre enn "John" når det gjelder leksikografisk rekkefølge, så resultatet er -1. Det fjerde dokumentet har et "tittel" -felt av 'Lisa', som er større enn "John" når det gjelder leksikografisk rekkefølge, så resultatet er 1.

Test> DB.Data.Aggregate ([$ Project: Tittel: 1, Resultat: $ strcaseCmp: ["$ tittel", "John"]]))
[_id: ObjectId ("63c90d6a42844a817c33167c"), tittel: 'John', resultat: 0,
_id: ObjectId ("63c90d6a42844a817c33167d"), tittel: 'John', resultat: 0,
_id: ObjectId ("63c90d6a42844a817c33167e"), tittel: 'idk', resultat: -1,
_id: ObjectId ("63c90d6a42844a817c33167f"), tittel: 'lisa', resultat: 1]

Eksempel # 03:

I vår siste illustrasjon vil vi bruke "DESC" -feltet i "Data" -samlingen som skal sammenlignes med en ny streng. $ StrcaseCMP -operatøren blir bestått to argumenter: “$ desc”, som er verdien av "Desc" -feltet i hvert dokument og "Idontknow", som er strengen som brukes som sammenligningsverdi.

Det første, andre og fjerde dokumentene har et "DESC" -felt av 'en tilfeldig fyr', som er mindre enn eller større enn strengen "Idontknow" når det gjelder leksikografisk rekkefølge. Så resultatet for disse postene er -1. Det tredje dokumentet har et "DESC" -felt av 'Idontknow', som er lik "Idontknow" uavhengig av bokstaver, så resultatet er 0.

Test> DB.Data.Aggregate ([$ Project: Desc: 1, Resultat: $ strcasecmp: ["$ desc", "idontknow"]]))
[_id: ObjectId ("63c90d6a42844a817c33167c"), desc: 'en tilfeldig fyr', resultat: -1,
_id: ObjectId ("63c90d6a42844a817c33167d"), desc: 'god gutt', resultat: -1,
_id: ObjectId ("63c90d6a42844a817c33167e"), desc: 'idontknow', resultat: 0,
_id: ObjectId ("63c90d6a42844a817c33167f"), desc: 'Enginnerer', resultat: -1]

Konklusjon

Denne guiden introduserer konseptet og bruken av StrcaseCMP -operatøren av MongoDB. Vi har opprettet en ny samling og utført Aggregate () -funksjonskommandoer sammen med STRCASECMP -operatøren for å demonstrere bruken av STRCASECMP -operatøren. Eksemplene som ble brukt i denne artikkelen demonstrerer hvordan en enkelt streng kan sammenlignes med et følsomt med strengverdier for innsamlingsfelt.