MongoDB $ DateFromParts y $ operadores de datetoparts
¿Cómo funcionan los $ dateFromparts y $ dateToparts en MongoDB?
Aquí se demuestra el uso de $ dateFromParts y los operadores $ datetoparts para obtener las fechas en consecuencia. Requerimos la colección de MongoDB que se utiliza para trabajar con estos operadores. Damos una colección "ChildbirthDate" donde se insertan los siguientes documentos utilizando el comando de inserción de MongoDB.
db.Parto.insertmany ([
"_id": 1,
"Birth_year": 2021,
"Birth_month": 09,
"Birth_day": 21,
"Birth_hour": 15,
"Birth_minute": 60,
"Birth_second": 31
,
"_id": 2,
"Birth_year": 2021,
"Birth_month": 09,
"Birth_day": 21,
"Birth_hour": 15,
"Birth_minute": 60,
"Birth_second": 31,
,
"_id": 3,
"Birth_year": 2023,
"Birth_month": 16,
"Birth_day": 90,
"Birth_hour": 47,
"Birth_minute": 190,
"Birth_second": 697
,
"_id": 4,
"Birth_year": 2022,
"Birth_month": 0,
"Birth_day": 0,
"Birth_hour": 0,
"Birth_minute": 0,
"Birth_second": 0
,
"_id": 5,
"Child_name": "Emily",
"Dob": Isodate ("2023-01-06T22: 35: 12.130Z ")
,
"_id": 6,
"Child_name": "Kim",
"Dob": Isodate ("2022-11-05T23: 10: 16.125Z ")
])
Los documentos se insertan dentro de la colección proporcionada como se muestra en la salida anterior. Podemos usar estos documentos para consultar los operadores de $ dateFromParts y $ datetoparts. Tenga en cuenta que usamos sobre el operador de $ DatefromParts en los primeros cuatro documentos porque las fechas en estos documentos se separan. Además de eso, el operador de $ datetoparts usa los dos últimos documentos ya que contienen los objetos de una sola fecha.
Reconocido: verdadero,
insertedids: '0': 1, '1': 2, '2': 3, '3': 4, '4': 5, '5': 6
Ejemplo 1: Uso del operador $ DateFromparts en MongoDB
El operador $ DateFromParts se usa aquí en el primer documento de la colección dada para obtener el objeto de una sola fecha. La expresión "_id: 1" se especifica en la etapa $ coincidencia. Luego, tenemos la etapa de proyecto $ donde se inserta el campo "Dateresult" para implementar el operador de $ DateFromparts. El operador de $ datefromParts ingresa los parámetros constituyentes de la fecha junto con los campos especificados del documento coincidente para dar el objeto de fecha.
db.Parto.agregar([
$ Match: _id: 1,
$ Proyecto:
Dateresult:
$ DateFromParts:
"Año": "$ birth_year", "mes": "$ birth_month", "día": "$ birth_day", "hora": "$ birth_hour"
])
La fecha única se recupera de todas las partes de las fechas en la salida por el operador de $ DatefromParts.
[_id: 1, Dateresult: isodate ("2021-09-21T15: 00: 00.000z ")]
Ejemplo 2: Uso del operador $ DateFromParts con una zona horaria especificada en MongoDB
También podemos usar el parámetro de zona horaria dentro del operador $ DatefromParts para obtener el objeto de fecha de una zona horaria determinada. Primero usamos el operador $ Match para que coincida con el documento predefinido que es "_id: 2". Luego, invocamos el operador de $ DatefromParts en el campo "Fecha" de la etapa de Project $. Utilizamos todos los parámetros de fecha que se necesitan para obtener el objeto de fecha además del parámetro "zona horaria". La "zona horaria" recibe una zona horaria de "Europa/Londres" para obtener la fecha resultante en esa zona especificada.
db.Parto.agregar([
$ Match: _id: 2,
$ Proyecto:
fecha:
$ DateFromParts:
"Año": "$ birth_year", "mes": "$ birth_month",
"Día": "$ Birth_day", "Hour": "$ Birth_Hour",
"minuto": "$ birth_minute", "segundo": "$ birth_second", "zona de tiempo": "Europa/Londres"
])
El operador $ DateFromParts devuelve el objeto de fecha siguiente de la zona horaria dada:
[_id: 2, fecha: isodate ("2021-09-21T15: 00: 31.000z ")]
Ejemplo 3: Uso del operador $ DatefromParts con una mayor gama de fechas en MongoDB
Aquí, obtenemos el objeto de fecha del segundo documento cuyas piezas de fecha son mayores que el rango. Dentro del operador $ datefromParts, utilizamos los parámetros constituyentes para generar un solo objeto de la fecha del rango que es mayor que los valores de fecha especificados. Establecimos los campos de los documentos de acuerdo con los parámetros constituyentes especificados. El operador $ DatefromParts aumenta el año "2023" a "2024" y luego establece el valor del mes en "12" para dar el objeto de una sola fecha de los valores de fecha no válidos.
db.Parto.agregar([
$ Match: _id: 3,
$ Proyecto:
DateFromParts:
$ DateFromParts:
"Año": "$ birth_year",
"Mes": "$ Birth_Month",
"Día": "$ Birth_day",
"Hora": "$ Birth_Hour",
"minuto": "$ birth_minute",
"Segundo": "$ birth_second"
])
Como se ve en la salida, los componentes de fecha en el objeto de fecha devuelto difieren de los valores de fecha correspondientes en el documento. La razón es que la fecha fue recalculada por $ DatefromParts para tener en cuenta los parámetros de fecha que están fuera del rango esperado.
[_id: 3, datefromParts: isodate ("2024-07-01T02: 21: 37.000z ")]
Ejemplo 4: Uso del operador $ DatefromParts con un rango menor que las fechas especificadas en MongoDB
Ahora, tenemos otro caso del operador de $ datefromParts donde los valores de la fecha son menores que el rango válido de fechas. Hacemos que coincida con el documento que contiene los campos de fecha y hora más allá de sus respectivos rangos aceptables. El documento cuyo "_id" es "3" se pasa dentro de la expresión de $ Match Stage. Después de eso, creamos el campo "DateFromParts" en la etapa de Project $. El campo "DateFromParts" se emplea con el operador de $ DateFromparts. El operador $ DateFromParts se pasa con sus parámetros asociados para obtener el objeto de fecha. Dado que tenemos todos los valores de los parámetros de fecha en el documento coincidente que son cero, que son menores que los valores mínimos de los rangos de fecha, el operador $ DatefromParts restablece todos los parámetros de fecha para generar el objeto de una sola fecha.
db.Parto.agregar([
$ Match: _id: 4,
$ Proyecto:
DateFromParts:
$ DateFromParts:
"Año": "$ birth_year",
"Mes": "$ Birth_Month",
"Día": "$ Birth_day",
"Hora": "$ Birth_Hour",
"minuto": "$ birth_minute",
"Segundo": "$ birth_second"
])
La fecha ISO única resultante se forma al siguiente operador de $ DatefromParts que cae el año "2022" por uno y limita el mes a 12.
[_id: 4, datefromParts: isodate ("2021-11-30t00: 00: 00.000z ")]
Ejemplo 5: Uso del operador $ DatoParts en MongoDB
Ahora, usamos otro operador de $ datetoparts del que se obtienen las piezas de fecha. Aquí, tenemos una demostración simple en la que coincidimos con el "_id" cuyo valor es "5" en la etapa inicial. Después de hacer coincidir el documento, la etapa de proyecto $ obtiene los resultados del operador $ DatoParts en el campo "dateInParts". El operador de $ dataToparts ingresa el parámetro "Fecha" que se proporciona con el campo "$ DOB". El campo $ DOB tiene el objeto de fecha que está separado en las piezas de fecha por el operador de $ Datetoparts.
db.Parto.agregar(
[
$ Match: _id: 5,
$ Proyecto:
_id: 0,
DateInParts: $ datetoparts: date: "$ dob"
]
)
El operador $ DatetoParts devuelve las piezas de fecha siguiente del campo $ DOB del documento coincidente:
[
DateInParts:
Año: 2023,
Mes: 1,
Día: 6,
Hora: 22,
Minuto: 35,
Segundo: 12,
milisegundo: 130
]
Ejemplo 6: Uso del operador $ DatoParts para el formato de fecha de la Semana ISO en MongoDB
Podemos usar la opción ISO8601 con el valor verdadero para actualizar el documento devuelto para usar los campos de fecha de la semana ISO. La fecha se calcula utilizando la especificación ISO 8601. Considere que modificamos el documento que tiene el "_id" igual al valor de "5". En ese documento, aplicamos el operador $ DatoParts donde el parámetro "Fecha" se establece con el campo "$ DOB". El parámetro "ISO8601" también se da con el valor que se establece en "Verdadero".
db.Parto.agregar(
[
$ Match: _id: 5,
$ Proyecto:
_id: 0,
DatePartsiso:
$ dataToparts:
Fecha: "$ Dob",
ISO8601: Verdadero
]
).bonito()
Las partes de la fecha de ese documento se obtienen del operador $ DatoParts que contiene el campo de la Semana ISO y los valores de la fecha.
[
DatePartsiso:
ISOWEEKYEAR: 2023,
Isoweek: 1,
isodayofweek: 5,
Hora: 22,
Minuto: 35,
Segundo: 12,
milisegundo: 130
]
Conclusión
Este artículo explicó los términos del método de tubería de la cartera de MongoDB, $ DateFromParts y $ DataToparts. Los $ datefromparts y los operadores de $ datoparts funcionan de manera opuesta entre sí. El operador $ DateFromParts ofrece la fecha del formato ISO de las piezas de la fecha. Por otro lado, el $ DatoParts toma la fecha de formato ISO para devolver las piezas de fecha con el valor. Exploramos a estos operadores con casos de ejemplos simples y complejos para aclarar el concepto de usar los operadores $ DateFromParts y $ DataToparts en MongoDB.