MongoDB $ delt operatør
Ordet split refererer til inndelingen av et spesifikt felt eller splitting av en streng i to eller flere underlag. Den delte operatøren av MongoDB jobber for å lage underlag for et bestemt felt av enhver samling som ligger i MongoDB -databasen. Akkurat som om vi bruker konseptet med et undergruppe som tilhører et bestemt sett i matematikk, tilhører underlagene som er opprettet av den delte operatøren en bestemt feltoppføring. I denne MongoDB -guiden skal vi diskutere bruken av den splittede operatøren av MongoDB for å dele en verdi av et spesifikt felt til to eller flere underlag ved bruk av avgrenser.
Eksempel 01:
For å komme i gang med MongoDB, bør vi sette opp et nytt skjema i databasen. I MongoDB kan skjemaet genereres ved hjelp av samlinger. Derfor bør du ha MongoDB Compass og MongoDB -skallet konfigurert på slutten. For det første trenger du en samling i databasen din som vil bli brukt for anvendelse av den delte operatøren. Derfor har vi opprettet en "data" med funksjonen "CreateCollection" ved å bruke samlingen "Data".
Test> DB.CreateCollection ("Data")
OK: 1
Vi starter den første illustrasjonen med innsetting av poster i en samling av "data". Derfor har MongoDBs InsertMany () -funksjon blitt brukt her for å sette inn 5 poster i samlingen. Hver av disse postene har 3 felt: ID, navn og admardat. Output -bekreftelsen viser at postene er satt inn i datainnsamlingen.
Test> DB.Data.InsertMany ([id: 1, navn: "Joe", Addate: "DEC-22-2020",
… Id: 2, navn: "Peter", Addate: "Nov-14-2021",
… Id: 3, navn: "Nina", Addate: "Nov-14-2018",
… Id: 4, navn: "Misha", Addate: "Jan-14-2022",
… Id: 5, navn: "Elen", Addate: "SEP-4-2021"])
anerkjent: sant,
innsats:
'0': ObjectId ("63BD2D8E01632FD3C02AB8D3"),
'1': ObjectId ("63BD2D8E01632FD3C02AB8D4"),
'2': ObjectId ("63BD2D8E01632FD3C02AB8D5"),
'3': ObjectId ("63BD2D8E01632FD3C02AB8D6"),
'4': ObjectId ("63BD2D8E01632FD3C02AB8D7")
Nå som postene i datainnsamlingen er satt inn i form av dokumenter, vil vi vise dem i MongoDB -konsollen i et JSON -format. Dermed vil Find () -funksjonen være til stor hjelp her. Bruken av Find () -funksjonen sammen med foreach () -funksjonen som tar "Printjson" som et argument viser postene som utdataene viser.
Test> DB.Data.finne().Foreach (Printjson)
°
_id: ObjectId ("63BD2D8E01632FD3C02AB8D4"), ID: 2, Navn: 'Peter', Addate: 'Nov-14-2021'
_id: ObjectId ("63BD2D8E01632FD3C02AB8D5"), ID: 3, Navn: 'Nina', Addate: 'Nov-14-2018'
°
°
I denne illustrasjonen har vi et "admdate" -felt som inneholder “-” karakter mellom måned, dag og år. Vi vil bruke “-” -karakteren for å dele opp admdatfeltet i underlag. For å bruke den delte operatøren, bør vi kaste av den samlede funksjonen til MongoDB sammen med innsamlingsnavnet som er "data". Denne funksjonen starter med "$ match" -operatøren som brukes her for å spesifisere posten ved å bruke et av feltene: ID: 2 Angir posten 2.
Etter dette kaster vi prosjektoperatøren for å bruke den splittede operatøren på "Admdate" -feltet i datainnsamlingen for å dele feltet i 3 underlag som tar "-" -karakteren som desimeter. "Navn" -feltet vil vises som det er mens feltet Addate -feltet blir erstattet med en ny tittel "Dato". Utgangen til utførelsen av denne instruksjonen viser navnefeltet til de 2nd Rekord som det er. Admdate-feltets tittel blir oppdatert som "dato", og verdien er blitt delt opp i tre underlag via hjelp av en avgrensning "-" og vises i en matrise.
Test> DB.Data.Aggregate ([$ match: id: 2, $ prosjekt: navn: 1, dato: $ split: ["$ admdate", "-"]]))
[_id: ObjectId ("63BD2D8E01632FD3C02AB8D4"), Navn: 'Peter', dato: ['nov', '14', '2021']]
Bruken av den delte operatøren oppdaterer bare runtime -resultatet uten å påvirke den faktiske posten i databasesamlingen. Illustrasjonen av dette konseptet har blitt vist med Find () -funksjonsinstruksjonen og utdataene for datainnsamlingen i vedlagte kodebit. "Admdate" -felt har vært det samme før bruken av en delt operatør.
Test> DB.Data.finn (id: 2)
[_id: ObjectId ("63BD2D8E01632FD3C02AB8D4"), ID: 2, Navn: 'Peter', Addate: 'Nov-14-2021']
Eksempel 02:
I eksemplet over har vi sett hvordan en splittet operatør kan brukes til å dele opp en feltoppføring i 2 eller flere underlag uten å oppdatere de originale postene. For å legge til et oppdatert felt (inneholder underlag) i samlingen, bør vi støpe fletteoperatøren sammen med den delte operatøren. Sørg for å skille fletteoperatøren (brukt på "Data" -samlingen) fra den delte operatøren (brukt på admardat -feltet). Denne spørringen returnerer ingenting til gjengjeld da den oppdaterte de originale postene til samlingen “Data” uten å vise noe på MongoDB -skallet.
Test> DB.Data.Aggregate ([$ prosjekt: dateInfo: $ split: ["$ admdate", "-"],
... $ Merge: "data"])
Ved å bruke fusjonsoperatøren i ovennevnte instruksjon for å spytte feltet Addate, har vi utdataene nedenfor.
Test> DB.Data.finne()
[°,
_id: ObjectId ("63BD2D8E01632FD3C02AB8D4"), ID: 2, Navn: 'Peter', Addate: 'Nov-14-2021', DateInfo: ['Nov', '14', '2021'],
_id: ObjectId ("63BD2D8E01632FD3C02AB8D5"), ID: 3, Navn: 'Nina', Addate: 'Nov-14-2018', DateInfo: ['Nov', '14', '2018'],
_id: ObjectId ("63BD2D8E01632FD3C02AB8D6"), ID: 4, Navn: 'Misha', Admdate: 'Jan-14-2022', DateInfo: ['Jan', '14', '2022'],
_id: ObjectId ("63BD2D8E01632FD3C02AB8D7"), ID: 5, Navn: 'Elen', Admardate: 'SEP-4-2021', DateInfo: ['Sep', '4', '2021']]
Eksempel 03:
La oss lage en ny samling som heter “Person” i samme database som skal brukes til vår nye illustrasjon. CreateCollection () vil bli støpt med navnet på samlingen i sin parameter.
Test> DB.CreateCollection ("Person")
OK: 1
Nå som samlingen er opprettet og er tom, må vi legge til dokumenter til den. Når vi skal legge til mer enn 1 post i "personen" -samlingen, bør vi bruke InsertMany () -funksjonen her. De 5 postene måtte legges til, og hver og hver inneholder 2 felt: ID og navn. Vi bruker navnefeltet for at den delte operatøren skal dele opp strengen i underlag.
Test> DB.Person.INSERTMANY ([id: 1, navn: "lia asif", id: 2, navn: "joly woe", id: 3, navn: "Eden kappe", id: 4, navn: " William Robert Patinson ", id: 5, navn:" Justin P Trudo "])
anerkjent: sant,
innsats:
'0': ObjectId ("63BD33E401632FD3C02AB8E1"),
'1': ObjectId ("63BD33E401632FD3C02AB8E2"),
'2': ObjectId ("63BD33E401632FD3C02AB8E3"),
'3': ObjectId ("63BD33E401632FD3C02AB8E4"),
'4': ObjectId ("63BD33E401632FD3C02AB8E5")
Etter at disse 5 postene er vellykket lagt til "Person" -samlingen via INSERTMANY () -funksjonen til MongoDB, kan vi endelig vise dem i en sekvens med en enkelt "finn" -funksjonsspørsmål som under. Utgangen fra denne enkle instruksjonen viser 5 poster av personsamlingen med unike ID -er.
Test> DB.Person.finne()
[°,
°,
°,
_id: ObjectId ("63BD33E401632FD3C02AB8E4"), ID: 4, Navn: 'William Robert Patinson',
_id: ObjectId ("63BD33E401632FD3C02AB8E5"), ID: 5, Navn: 'Justin P Treudo']
Som vi har nevnt før, vil vi bruke navnefeltet for å forstå den splittede operatøren mer. Derfor kommer her den samlede funksjonen igjen sammen med prosjektoperatøren i den. Denne gangen kommer vi til å dele navnfeltet med det enkeltrommet mellom underlagene til dets verdier. Tittelen på feltet "Navn" blir erstattet av "tittelen". Etter å ha satt denne spørringen, har vi kjørt den i MongoDB -skallet, og det viser de splittede verdiene til navnefeltet i en matrise "tittel" for alle poster i.e. Et enkelt navn er blitt delt i 2 eller flere underlag.
Test> DB.Person.Aggregate ([$ prosjekt: tittel: $ split: ["$ name", ""]])
[°,
_id: ObjectId ("63BD33E401632FD3C02AB8E2"), Tittel: ['Joly', 'Woe'],
_id: ObjectId ("63BD33E401632FD3C02AB8E3"), tittel: ['Eden', 'kappe'],
°,
_id: ObjectId ("63BD33E401632FD3C02AB8E5"), tittel: ['Justin', 'P', 'Trudo']]
Konklusjon
Denne MongoDB -guiden diskuterer den splittede operatørbruken i MongoDB mens den sammenligner med konseptet med undergrupper i matematikk. For å støtte vår forklaring har vi diskutert 2-3 illustrasjoner av MongoDB i form av kodebit. Disse kodeeksemplene illustrerer hvordan en delt operatør kan brukes til å dele opp verdiene til et bestemt felt i underlag ved kjøretid og for permanent endring i databasesamlingen.