MongoDB $ Dateadd y $ operadores de fechas
Cómo usar los operadores MongoDB $ Dateadd y $ Datesubtract
Aquí, usamos los operadores $ Dateadd y $ Datesubtract en MongoDB que devuelven las fechas esperadas de acuerdo con el operador dado. Considere la colección "EnlinedEnterive" donde insertamos algunos documentos con el método InsertMany (). Estos documentos se utilizan sobre los operadores $ Dataadd y $ Datesubtract para demostrar su rendimiento en MongoDB.
db.Entrada en la entrega.insertMany (
[
Id: 05,
OrderDate: Isodate ("2021-12-30"),
PaymentDate: Isodate ("2022-02-19T15: 20: 00"),
Ubicación: "America/New_york",
Id: 09,
OrderDate: Isodate ("2022-01-18"),
PaymentDate: Isodate ("2023-01-04T16: 10: 00"),
Ubicación: "America/New_york",
Id: 45,
OrderDate: Isodate ("2020-03-24"),
PaymentDate: Isodate ("2021-05-31T21: 00: 00"),
Ubicación: "America/New_york",
Id: 55,
OrderDate: Isodate ("2023-09-20"),
PaymentDate: Isodate ("2023-12-31T21: 00: 00"),
Ubicación: "America/New_york"
]
)
Después de la inserción de los documentos anteriores dentro de la colección "EnlinedEnterive", la salida se representa como en lo siguiente que reconoce que se agregan los documentos:
Reconocido: verdadero,
insertedids:
'0': ObjectId ("63C298E9AD100B03EAD18BEE"),
'1': ObjectId ("63C298E9AD100B03EAD18BEF"),
'2': ObjectId ("63C298E9AD100B03EAD18BF0"),
'3': ObjectId ("63C29CEFAD100B03EAD18BF4")
Ejemplo 1: Uso del operador $ Dataadd en MongoDB
El operador $ Dateadd se utiliza para configurar la fecha futura de la fecha original especificada. Aquí, el operador $ Dateadd se emplea en el campo del operador del proyecto $, "entrega". Queremos la fecha de entrega esperada de la fecha del pedido. Entonces, dentro del operador $ Dataadd, establecemos el parámetro "StartDate" requerido con el campo "OrderDate". El parámetro "StartDate" debe ser la fecha de inicio en formato UTC. Después de eso, tenemos un parámetro de "unidad" que se especifica con el valor "día". El parámetro "Unidad" indica el incremento de tiempo que se adjunta a la "Cita de inicio". Luego, proporcionamos el parámetro de "cantidad" con el número "4" que agrega cuatro días al "inicio de la fecha".
db.Entrada en la entrega.agregar(
[
$ Proyecto:
Fecha de entrega:
$ Dataadd:
StartDate: "$ OrderDate",
Unidad: "Día",
Cantidad: 4
])
El pedido de pedidos se incrementa por una unidad "4" que se muestra en el campo "EntrewingDate". Estas fechas son los tiempos esperados para entregar el pedido.
[
_id: ObjectId ("63C298E9AD100B03EAD18BEE"),
EntrewingDate: Isodate ("2022-01-03T00: 00: 00.000z ")
,
_id: ObjectId ("63C298E9AD100B03EAD18BEF"),
EntrewingDate: Isodate ("2022-01-22T00: 00: 00.000z ")
,
_id: ObjectId ("63C298E9AD100B03EAD18BF0"),
EntrewingDate: Isodate ("2020-03-28T00: 00: 00.000z ")
,
_id: ObjectId ("63C29CEFAD100B03EAD18BF4"),
EntrewingDate: Isodate ("2023-09-24T00: 00: 00.000z ")
]
Ejemplo 2: Uso del operador $ Dateadd en MongoDB para filtrar una rango de fecha
Utilizamos el $ Dateadd en un operador $ Match para construir un filtro que coincida con los documentos dentro de un rango de fechas que se determina por una fecha de inicio y un marco de tiempo especificado por el operador $ Dateadd. Considere el guión de MongoDB. Tenemos una etapa de $ Match dentro del método agregado. La etapa $ coincidencia se define con el operador $ exp donde se especifica la expresión condicional de $ gt. El operador $ GT coincide con el documento que satisface la condición dada. Establecimos el campo $ PaymentDate en el operador $ GT que se compara con la fecha que se obtiene del operador $ Dateadd.
Establecimos el "startDate" con los parámetros "OrderDate" en el operador $ Dataadd. La "unidad" se da como "mes" y la "cantidad" que se agregará en las fechas se proporciona como "13". Aquí, los documentos cuyas fechas de entrega son mayores que los "13" meses desde el "pedido de pedidos" se transmiten al operador $ del proyecto. Luego, el operador de proyecto $ se implementa con el campo "Orden" que tiene la expresión del operador $ dataToString para transformar las fechas en un formato mejor legible.
db.Entrada en la entrega.agregar(
[
$ Match:
$ expr:
$ GT:
["$ PaymentDate",
$ Dataadd:
StartDate: "$ OrderDate",
Unidad: "Mes",
Cantidad: 13
]
,
$ Proyecto:
_id: 0,
OrderDate: 1,
Orden:
$ dataToString:
Formato: "%y-%m-%d",
Fecha: "$ Orderdate"
])
Al ejecutar la consulta anterior, tenemos dos registros del operador $ Dateadd que satisface la condición.
[
OrderDate: Isodate ("2020-03-24T00: 00: 00.000z "),
Orden: '2020-03-24'
,
OrderDate: Isodate ("2020-03-24T00: 00: 00.000z "),
Orden: '2020-03-24'
]
Ejemplo 3: Uso del operador $ Dateadd en MongoDB por una hora
El operador $ Dateadd utiliza el tiempo para realizar los cálculos cuando se define una zona horaria. Aquí, usamos el operador $ Dateadd para incrementar la fecha en una hora. Para esto, tenemos que modificar el parámetro "Unidad" del operador $ Dataadd. Hemos dado un nuevo campo de "horas" en el operador de proyecto $. El campo "Horas" está definido por el operador "$ dataToString" para la conversión de la fecha en formato de cadena que devuelve el operador $ Dateadd. El operador $ Dataadd se especifica con el "startDate" donde se proporciona el campo $ OrderDate. Luego, usamos el parámetro "Unidad" para establecer la "hora" allí. Después de eso, establecemos el parámetro de "cantidad" en "24" y establecemos la "zona horaria" con el campo "$ ubicación" cuando el operador $ dateadd incrementa la fecha en una hora.
db.Entrada en la entrega.agregar(
[
$ Proyecto:
horas:
$ dataToString:
Formato: "%y-%m-%d%h:%m",
fecha:
$ Dataadd:
StartDate: "$ OrderDate",
Unidad: "Hora",
Cantidad: 24,
TimeZone: "$ ubicación"
]
).bonito()
Recuperamos las mismas fechas que las fechas originales porque el operador $ Dateadd agregó las fechas por horas en el número de monto "24".
_id: ObjectId ("63C298E9AD100B03EAD18BEE"),
Horario: '2021-12-31 00:00'
,
_id: ObjectId ("63C298E9AD100B03EAD18BEF"),
Horario: '2022-01-19 00:00'
,
_id: ObjectId ("63C298E9AD100B03EAD18BF0"),
Horario: '2020-03-25 00:00'
]
Ejemplo 4: Uso del operador $ Datesubtract en MongoDB para disminuir una fecha
En los casos anteriores de MongoDB, utilizamos el operador $ Dateadd para obtener la fecha esperada en el futuro. Ahora, usamos el operador $ DatesUbtract de MongoDB que obtiene la fecha prevista pasada de la fecha dada actual. El operador $ DatesUbtract ingresa todos los parámetros igual que los parámetros en el operador $ Dataadd. Tenga en cuenta que usamos el $ Datesubtract dentro del campo "ExpectedOrderDate" del operador de proyecto $. Allí, el operador $ DatesUbtract ingresa el parámetro "StartDate" con el campo "$ PayementDate" para la resta de la fecha para obtener la fecha esperada del pedido.
Luego, establecemos el argumento de la "unidad" en el "mes" para representar el tiempo que se quita la fecha de inicio. El siguiente es el parámetro de "cantidad" que se define con el número "2" para disminuir la fecha con este valor.
db.Entrada en la entrega.agregar(
[
$ Proyecto:
esperado orden:
$ Datesubtract:
StartDate: "$ PaymentDate",
Unidad: "Mes",
Cantidad: 2
])
Las fechas esperadas son devueltas por el operador $ Datesubtract, que son las fechas dos meses antes de las fechas reales.
[
_id: ObjectId ("63C298E9AD100B03EAD18BEE"),
esperado ordenador: isodate ("2021-12-19T15: 20: 00.000z ")
,
_id: ObjectId ("63C298E9AD100B03EAD18BEF"),
esperado ordenador: isodate ("2022-11-04T16: 10: 00.000z ")
,
_id: ObjectId ("63C298E9AD100B03EAD18BF0"),
esperado ordenador: isodate ("2021-03-31T21: 00: 00.000z ")
]
Ejemplo 5: Uso del operador $ Datesubtract en MongoDB para clasificar según las fechas relativas
Además, podemos establecer un filtro de rango dependiendo del tiempo de ejecución de la consulta utilizando la expresión $ Datesubtract. Empleamos la etapa $ coincidencia en el método agregado para que coincida con las fechas relativas. La etapa $ coincidencia tiene la expresión establecida con el operador $ expr. El operador de $ expr utiliza los operadores $ GT y $ Datesubtract para limitar los documentos coincidentes con un pago de pago dentro de la última semana. El operador $ Datesubtract proporciona la fecha actual de formato ISO ya que la variable $$ ahora se especifica al operador StartDate. Luego, la fecha de disminución que se obtiene del operador $ Datesubtract se transforma en el formato de cadena mediante el "$ dataToString" que se emplea dentro del operador de proyecto $.
db.Entrada en la entrega.agregar(
[
$ Match:
$ expr:
$ GT:
[
"$ PaymentDate",
$ Datesubtract:
StartDate: "$$ ahora",
Unidad: "Semana",
Cantidad: 1
]
,
$ Proyecto:
_id: 0,
ID: 1,
Pago:
$ dataToString:
Formato: "%y-%m-%d",
Fecha: "$ PaymentDate"
]
)
Solo tenemos un registro que es recuperado por el operador $ Datesubtract.
[Id: 55, pago: '2023-12-31']
Conclusión
Los operadores MongoDB $ Dateadd y $ Datesubtract se demuestran en esta guía. Utilizamos estos operadores con ejemplos en los que se explora el parámetro asociado con cada operador. Primero, tenemos un script de ejemplo del operador $ Dateadd para agregar las fechas con un número determinado de un número con la zona horaria. El operador $ Dateadd se implementa además para obtener la fecha futura dentro de un rango y obtener la fecha esperada especificando la hora como una unidad. Después de eso, el operador $ Datesubtract se explora con el ejemplo para obtener las fechas pasadas.