MongoDB $ DateAdd og $ Datesubtract Operators
Hvordan bruke MongoDB $ DateAdd og $ DateSubtract -operatører
Her bruker vi $ DateAdd og $ Datesubtract -operatørene i MongoDB som returnerer forventede datoer i henhold til den gitte operatøren. Tenk på "OnlinedLivery" -samlingen der vi setter inn noen få dokumenter med InsertMany () -metoden. Disse dokumentene brukes over $ DateAdd og $ Datesubtract -operatørene for å demonstrere deres ytelse i MongoDB.
db.Onlinedlevering.InsertMany (
[
Id: 05,
Orderdate: Isodate ("2021-12-30"),
Betalingsdato: Isodate ("2022-02-19T15: 20: 00"),
Sted: "America/new_york",
Id: 09,
Orderdate: Isodate ("2022-01-18"),
Betalingsdato: Isodate ("2023-01-04T16: 10: 00"),
Sted: "America/new_york",
Id: 45,
Orderdate: Isodate ("2020-03-24"),
Betalingsdato: Isodate ("2021-05-31T21: 00: 00"),
Sted: "America/new_york",
Id: 55,
Orderdate: Isodate ("2023-09-20"),
Betalingsdato: Isodate ("2023-12-31T21: 00: 00"),
Sted: "America/new_york"
]
)
Etter innsetting av de tidligere dokumentene i samlingen "OnlinedLivery", er utdataene representert som i det følgende som erkjenner at dokumentene er lagt til:
Anerkjent: sant,
innsats:
'0': ObjectId ("63c298e9ad100b03ead18bee"),
'1': ObjectId ("63c298e9ad100b03ead18Bef"),
'2': ObjectId ("63c298e9ad100b03ead18bf0"),
'3': ObjectId ("63C29CEFAD100B03EAD18BF4")
Eksempel 1: Bruke $ DateAdd -operatøren i MongoDB
$ DateAdd -operatøren brukes til å konfigurere fremtidig dato for den angitte opprinnelige datoen. Her er $ DateAdd -operatøren ansatt i feltet $ Project Operator, "DeliveryDate". Vi vil ha forventet leveringsdato for bestillingsdatoen. Så innen $ DateAdd -operatøren setter vi den nødvendige "startdate" -parameteren med "Orderdate" -feltet. "Startdate" -parameteren skal være begynnelsesdatoen i UTC -format. Etter det har vi en "enhet" -parameter som er spesifisert med "Day" -verdien. "Enhet" -parameteren indikerer tidsøkningen som er vedlagt "StartDate". Deretter gir vi "beløp" -parameteren med tallet "4" som legger fire dager til "startdate".
db.Onlinedlevering.aggregat (
[
$ prosjekt:
Leveringsdato:
$ dateAdd:
StartDate: "$ OrderDate",
Enhet: "Dag",
Beløp: 4
])
Orderdatoene økes med en "4" enhet som vises i "leveringsdato" -feltet. Disse datoene er forventede tider for å levere bestillingen.
[
_ID: ObjectId ("63C298E9AD100B03EAD18BEE"),
Leveringsdato: Isodate ("2022-01-03T00: 00: 00.000z ")
,
_ID: ObjectID ("63C298E9AD100B03EAD18BEF"),
Leveringsdato: Isodate ("2022-01-22t00: 00: 00.000z ")
,
_ID: ObjectID ("63C298E9AD100B03EAD18BF0"),
Leveringsdato: Isodate ("2020-03-28T00: 00: 00.000z ")
,
_ID: ObjectID ("63C29CEFAD100B03EAD18BF4"),
Leveringsdato: Isodate ("2023-09-24T00: 00: 00.000z ")
]
Eksempel 2: Bruke $ DateADD -operatøren i MongoDB for å filtrere en rekke dato
Vi bruker $ DateAdd i en $ Match -operatør for å bygge et filter som samsvarer med dokumentene innen en rekke datoer som bestemmes av en startdato og en tidsramme som er spesifisert av $ DateAdd -operatøren. Tenk på skriptet til MongoDB. Vi har et $ match -trinn i den samlede metoden. $ Match -trinnet er definert med $ Exp -operatøren der betinget uttrykk for $ GT er spesifisert. $ GT -operatøren samsvarer med dokumentet som tilfredsstiller den gitte tilstanden. Vi setter $ PaymentDate -feltet i $ GT -operatøren som sammenlignes med datoen som er innhentet fra $ DateAdd -operatøren.
Vi setter "StartDate" med "Orderdate" -parametrene til $ DateAdd -operatøren. "Enheten" er gitt som "måned" og "beløpet" som skal legges til i datoene er gitt som "13". Her blir dokumentene hvis leveringsdatoer er større enn "13" måneder fra "Orderdate" overført til $ prosjektoperatøren. Deretter distribueres $ prosjektoperatør.
db.Onlinedlevering.aggregat (
[
$ kamp:
$ expr:
$ gt:
["$ Betalingsdato",
$ dateAdd:
StartDate: "$ OrderDate",
Enhet: "Måned",
Beløp: 13
]
,
$ prosjekt:
_id: 0,
Orderdate: 1,
Rekkefølge:
$ DATETOSTRING:
Format: "%y-%m-%d",
Dato: "$ OrderDate"
])
Når vi utfører den forrige spørringen, har vi to poster fra $ Dateadd -operatøren som tilfredsstiller tilstanden.
[
Orderdate: Isodate ("2020-03-24T00: 00: 00.000z "),
Bestilling: '2020-03-24'
,
Orderdate: Isodate ("2020-03-24T00: 00: 00.000z "),
Bestilling: '2020-03-24'
]
Eksempel 3: Bruke $ DateAdd -operatøren i MongoDB med en time
$ DateAdd -operatøren bruker tiden til å utføre beregningene når en tidssone er definert. Her bruker vi $ Dateadd -operatøren for å øke datoen med en time. For dette må vi endre "Enhet" -parameteren til $ DateAdd -operatøren. Vi har gitt et nytt "timer" -felt i $ prosjektoperatøren. "Timer" -feltet er ytterligere definert av "$ DateString" -operatøren for konvertering av datoen i strengformat som returneres av $ DateADD -operatøren. $ DateAdd -operatøren er spesifisert med "startdate" der $ ordreDate -feltet er gitt. Deretter bruker vi "enhet" -parameteren for å stille inn "timen" der. Etter det setter vi parameteren "Mengde" til "24" og setter "TimeZone" med "$ Location" -feltet når $ DateAdd -operatøren øker datoen med en time.
db.Onlinedlevering.aggregat (
[
$ prosjekt:
timer:
$ DATETOSTRING:
Format: "%y-%m-%d%h:%m",
Dato:
$ dateAdd:
StartDate: "$ OrderDate",
Enhet: "time",
Beløp: 24,
TIMEZONE: "$ Location"
]
).ganske()
Vi hentet de samme datoene som de opprinnelige datoene fordi $ DateAdd -operatøren la til datoene med timer i "24" -beløpsnummeret.
_ID: ObjectId ("63C298E9AD100B03EAD18BEE"),
Timer: '2021-12-31 00:00'
,
_ID: ObjectID ("63C298E9AD100B03EAD18BEF"),
Timer: '2022-01-19 00:00'
,
_ID: ObjectID ("63C298E9AD100B03EAD18BF0"),
Timer: '2020-03-25 00:00'
]
Eksempel 4: Bruke $ Datesubtract -operatøren i MongoDB for å redusere en dato
I de tidligere tilfellene av MongoDB brukte vi $ DateAdd -operatøren for å få den forventede datoen i fremtiden. Nå bruker vi $ Datesubtract -operatøren av MongoDB som får den tidligere forventede datoen fra gjeldende gitt dato. $ Datesubtract -operatøren legger inn alle parametrene de samme som parametrene i $ DateAdD -operatøren. Merk at vi bruker $ DateSubtract i "forventet ordre" -feltet til $ prosjektoperatøren. Der legger $ Datesubtract -operatøren inn "StartDate" -parameteren med "$ PayementDate" -feltet for subtraksjon av datoen for å få forventet dato for ordren.
Deretter satte vi "enhet" -argumentet med "måneden" for å representere tiden som blir tatt bort fra startdato. Neste er parameteren "beløp" som er definert med tallet "2" for å redusere datoen med denne verdien.
db.Onlinedlevering.aggregat (
[
$ prosjekt:
forventet ordre:
$ dateSubtract:
StartDate: "$ PaymentDate",
Enhet: "Måned",
Beløp: 2
])
De forventede datoene blir returnert av $ Datesubtract -operatøren som er datoene to måneder før de faktiske datoene.
[
_ID: ObjectId ("63C298E9AD100B03EAD18BEE"),
Forventet Orddato: ISODATE ("2021-12-19T15: 20: 00.000z ")
,
_ID: ObjectID ("63C298E9AD100B03EAD18BEF"),
Forventet Orddato: Isodate ("2022-11-04T16: 10: 00.000z ")
,
_ID: ObjectID ("63C298E9AD100B03EAD18BF0"),
Forventet Orddato: ISODATE ("2021-03-31T21: 00: 00.000z ")
]
Eksempel 5: Bruke $ Datesubtract -operatøren i MongoDB for å sortere basert på relative datoer
I tillegg kan vi etablere et områdefilter avhengig av utførelsestiden for spørringen ved hjelp av $ datoubract -uttrykket. Vi bruker $ Match -trinnet i den samlede metoden for å matche de relative datoene. $ Match -trinnet har uttrykket som er satt med $ expr -operatøren. $ Expr -operatøren bruker $ GT og $ Datesubtract -operatørene for å begrense de matchede dokumentene med en betalingsdato i løpet av den siste uken. $ Datesubtract -operatøren gir gjeldende ISO -formatdato da $$ nå variabelen er spesifisert til StartDate -operatøren. Deretter blir reduksjonsdatoen som er hentet fra $ Datesubtract -operatøren transformert til strengformatet av "$ datetoString" som er ansatt i $ prosjektoperatøren.
db.Onlinedlevering.aggregat (
[
$ kamp:
$ expr:
$ gt:
[
"$ Betalingsdate",
$ dateSubtract:
Startdato: "$$ nå",
Enhet: "Uke",
Beløp: 1
]
,
$ prosjekt:
_id: 0,
ID: 1,
Innbetaling:
$ DATETOSTRING:
Format: "%y-%m-%d",
Dato: "$ PaymentDate"
]
)
Vi har bare en rekord som blir hentet av $ Datesubtract -operatøren.
[Id: 55, betaling: '2023-12-31']
Konklusjon
MongoDB $ DateAdd og $ Datesubtract -operatørene er demonstrert i denne guiden. Vi brukte disse operatørene med eksempler der parameteren som er assosiert med hver operatør blir utforsket. Først har vi et eksempel på skriptet til $ DateAdd -operatøren for å legge til datoene med en gitt mengde av et tall med tidssonen. $ DateAdd -operatøren blir ytterligere distribuert for å få fremtidig dato innen et område og få den forventede datoen ved å spesifisere timen som en enhet. Etter det utforskes $ Datesubtract -operatøren med eksemplet for å få fortidsdatoer.