MongoDB $ Operador Split
La palabra dividida se refiere a la división de un campo específico o división de una cadena en dos o más subcadenas. El operador dividido de MongoDB trabaja para crear sustraciones para un campo particular de cualquier colección que reside en la base de datos MongoDB. Al igual que usamos el concepto de un subconjunto que pertenece a un conjunto particular en Matemáticas, las subcadenas creadas por el operador dividido pertenecen a un registro de campo específico. En esta guía de MongoDB, vamos a discutir el uso del operador dividido de MongoDB para dividir un valor de un campo específico a dos o más subcadenas usando delimitador.
Ejemplo 01:
Para comenzar con MongoDB, debemos configurar un nuevo esquema en su base de datos. En MongoDB, el esquema se puede generar utilizando colecciones. Por lo tanto, debe tener MongoDB Compass y MongoDB Shell configurados al final. En primer lugar, necesita una colección en su base de datos que se utilizará para la aplicación del operador dividido. Por lo tanto, hemos estado creando un "datos" con la función "createCollection" utilizando la recopilación "datos".
Prueba> DB.createCollection ("datos")
OK: 1
Comenzamos la primera ilustración con la inserción de registros en una colección de "datos". Por lo tanto, la función insertMany () de MongoDB se ha utilizado aquí para insertar 5 registros en la colección. Cada uno de estos registros tiene 3 campos: ID, nombre y admisión. El reconocimiento de salida muestra que los registros se insertan correctamente dentro de la recopilación de datos.
Prueba> DB.Datos.insertMany ([id: 1, nombre: "Joe", admdate: "Dic-22-2020",
... id: 2, nombre: "Peter", Admedate: "Nov-14-2021",
... id: 3, nombre: "Nina", Admedate: "Nov-14-2018",
... id: 4, nombre: "Misha", Admedate: "Jan-14-2022",
... id: 5, nombre: "Elen", admde: "septiembre 4-2021"])
Reconocido: Verdadero,
insertedids:
'0': ObjectId ("63BD2D8E01632FD3C02AB8D3"),
'1': ObjectId ("63BD2D8E01632FD3C02AB8D4"),
'2': ObjectId ("63BD2D8E01632FD3C02AB8D5"),
'3': ObjectId ("63BD2D8E01632FD3C02AB8D6"),
'4': ObjectId ("63BD2D8E01632FD3C02AB8D7")
Ahora que los registros en la recopilación de datos se insertan en forma de documentos, los mostraremos en la consola MongoDB en formato JSON. Por lo tanto, la función Find () sería de gran ayuda aquí. El uso de la función find () junto con la función foreach () tomando "printjson" como un argumento muestra los registros como lo demuestra la salida.
Prueba> DB.Datos.encontrar().foreach (printjson)
_id: ObjectId ("63BD2D8E01632FD3C02AB8D3"), ID: 1, Nombre: 'Joe', AdmDate: 'Dec-22-2020'
_id: ObjectId ("63BD2D8E01632FD3C02AB8D4"), ID: 2, Nombre: 'Peter', AdmDate: 'Nov-14-2021'
_id: ObjectId ("63BD2D8E01632FD3C02AB8D5"), ID: 3, Nombre: 'Nina', AdmDate: 'Nov-14-2018'
_id: ObjectId ("63BD2D8E01632FD3C02AB8D6"), ID: 4, Nombre: 'Misha', AdmDate: 'Jan-14-2022'
_id: ObjectId ("63BD2D8E01632FD3C02AB8D7"), ID: 5, Nombre: 'Elen', AdmDate: 'SEP-4-2021'
En esta ilustración, tenemos un campo "Admdate" que contiene el personaje "-" entre mes, día y año. Usaremos el personaje "-" para dividir el campo de admisión en subcadenas. Para usar el operador dividido, deberíamos estar eliminando la función agregada de MongoDB junto con el nombre de la recopilación que es "datos". Esta función comienza con el operador "$ Match" que se usa aquí para especificar el registro usando uno de sus campos: ID: 2 Especifica el registro 2.
Después de esto, estamos expulsando al operador del proyecto para utilizar el operador dividido en el campo "Admdate" de la recopilación de datos para dividir el campo en 3 subcadenas que toman el carácter "-" como el decímetro. El campo "Nombre" se mostrará tal como es, mientras que el campo ADMDATE del campo será reemplazado por un nuevo título "Fecha". La salida de la ejecución de esta instrucción muestra el campo Nombre de los 2Dakota del Norte registrar como es. El título del campo Admdate se actualiza como "fecha" y su valor se ha dividido en tres subcadenas a través de la ayuda de un delimitador "-" y se muestra en una matriz.
Prueba> DB.Datos.Aggregate ([[$ Match: id: 2, $ Project: Nombre: 1, fecha: $ Split: ["$ admdate", "-"]]))
[_id: ObjectId ("63BD2D8E01632FD3C02AB8D4"), Nombre: 'Peter', fecha: ['Nov', '14', '2021']]
El uso del operador dividido solo actualiza el resultado del tiempo de ejecución sin afectar el registro real en la colección de la base de datos. La ilustración de este concepto se ha mostrado con la instrucción de función find () y su salida para la recopilación de datos en el fragmento de código adjunto. El campo "Admdate" ha sido el mismo antes del uso de un operador dividido.
Prueba> DB.Datos.Find (id: 2)
[_id: ObjectId ("63BD2D8E01632FD3C02AB8D4"), ID: 2, nombre: 'Peter', admdate: 'nov-14-2021']
Ejemplo 02:
En el ejemplo anterior, hemos visto cómo se puede usar un operador dividido para dividir un registro de campo en 2 o más subcadenas sin actualizar los registros originales. Para agregar un campo actualizado (contiene subcadenas) dentro de la colección, deberíamos lanzar el operador de fusión junto con el operador dividido. Asegúrese de separar el operador de fusión (aplicado en la colección "Datos") del operador dividido (aplicado en el campo ADMDATE). Esta consulta no devuelve nada a cambio, ya que actualizó los registros originales de la colección "datos" sin mostrar nada en el shell de MongoDB.
Prueba> DB.Datos.Aggregate ([$ Project: dateInfo: $ Split: ["$ admdate", "-"],
... $ fusion: "data"])
Usando el operador de fusión en nuestra instrucción anterior para escupir el campo de admisión, tenemos la salida a continuación.
Prueba> DB.Datos.encontrar()
[_id: ObjectId ("63BD2D8E01632FD3C02AB8D3"), ID: 1, nombre: 'Joe', admdate: 'Dec-22-2020', dateInfo: ['dec', '22', '2020'],
_id: ObjectId ("63BD2D8E01632FD3C02AB8D4"), ID: 2, nombre: 'Peter', AdmDate: 'Nov-4-2021', DateInfo: ['Nov', '14', '2021'],
_id: ObjectId ("63bd2d8e01632fd3c02ab8d5"), id: 3, nombre: 'nina', admdate: 'nov-14-2018', dateInfo: ['nov', '14', '2018'],
_id: ObjectId ("63bd2d8e01632fd3c02ab8d6"), id: 4, nombre: 'misha', admde: 'enero-14-2022', dateInfo: ['Jan', '14', '2022'],
_id: objectId ("63bd2d8e01632fd3c02ab8d7"), id: 5, nombre: 'elen', admdate: 'sep-4-2021', dateInfo: ['sep', '4', '2021']]]
Ejemplo 03:
Creemos una nueva colección llamada "persona" en la misma base de datos para usar para nuestra nueva ilustración. La createCollection () se descartará con el nombre de la colección en su parámetro.
Prueba> DB.createCollection ("persona")
OK: 1
Ahora que la colección está creada y está vacía, tenemos que agregarle documentos. Como vamos a agregar más de 1 registro en la colección "persona", deberíamos usar la función insertMany () aquí. Se necesitan agregar los 5 registros y cada uno contiene 2 campos: ID y nombre. Usaremos el campo Nombre para que el operador dividido divida su cadena en sustros.
Prueba> DB.Persona.insertMany ([id: 1, nombre: "lia asif", id: 2, nombre: "joly woe", id: 3, nombre: "eden robe", id: 4, nombre: " William Robert Patinson ", id: 5, nombre:" Justin P Trudo "])
Reconocido: Verdadero,
insertedids:
'0': ObjectId ("63BD33E401632FD3C02AB8E1"),
'1': ObjectId ("63BD33E401632FD3C02AB8E2"),
'2': ObjectId ("63BD33E401632FD3C02AB8E3"),
'3': ObjectId ("63BD33E401632FD3C02AB8E4"),
'4': ObjectId ("63BD33E401632FD3C02AB8E5")
Después de que estos 5 registros se agregan con éxito a la colección "persona" a través de la función InsertMany () de MongoDB, finalmente podemos mostrarlos en una secuencia con una sola consulta de la función "Find" como debajo de. La salida de esta instrucción simple muestra 5 registros de la colección de personas con identificaciones únicas.
Prueba> DB.Persona.encontrar()
[_id: ObjectId ("63BD33E401632FD3C02AB8E1"), ID: 1, nombre: 'lia asif',
_id: ObjectID ("63BD33E401632FD3C02AB8E2"), ID: 2, Nombre: 'Joly Woe',
_id: ObjectId ("63BD33E401632FD3C02AB8E3"), ID: 3, Nombre: 'Eden Robe',
_id: ObjectId ("63BD33E401632FD3C02AB8E4"), ID: 4, Nombre: 'William Robert Patinson',
_id: ObjectId ("63BD33E401632FD3C02AB8E5"), ID: 5, Nombre: 'Justin P Treudo']
Como hemos mencionado anteriormente, utilizaremos el campo de nombre para comprender el operador dividido más. Por lo tanto, aquí viene la función agregada una vez más junto con el operador del proyecto en él. Esta vez, vamos a dividir el campo de nombre con el espacio único entre las subcadenas de sus valores. El título del campo "Nombre" será reemplazado por el "título". Después de configurar esta consulta, la hemos estado ejecutando en el shell MongoDB y muestra los valores divididos del campo de nombre en una matriz "Título" para todos los registros I.mi. Se ha dividido un solo nombre en 2 o más subcadenas.
Prueba> DB.Persona.Aggregate ([$ Project: Título: $ Split: ["$ name", ""]]))
[_id: ObjectId ("63BD33E401632FD3C02AB8E1"), Título: ['lia', 'asif'],
_id: ObjectId ("63BD33E401632FD3C02AB8E2"), Título: ['Joly', 'Woe'],
_id: ObjectId ("63BD33E401632FD3C02AB8E3"), Título: ['Eden', 'Robe'],
_id: ObjectId ("63BD33E401632FD3C02AB8E4"), Título: ['William', 'Robert', 'Patinson'],
_id: ObjectId ("63BD33E401632FD3C02AB8E5"), Título: ['Justin', 'P', 'Trudo']]
Conclusión
Esta guía de MongoDB analiza el uso del operador dividido en MongoDB mientras hace su comparación con el concepto de subconjuntos en matemáticas. Para apoyar nuestra explicación, hemos discutido 2-3 ilustraciones de MongoDB en forma de fragmentos de código. Estos ejemplos de código ilustran cómo se puede utilizar un operador dividido para dividir los valores de un campo particular en subcadenas en tiempo de ejecución y para un cambio permanente en la colección de la base de datos.