Cómo gestionar documentos en MongoDB

Introducción

Al usar MongoDB, pasará la mayor parte de su tiempo administrando documentos de una forma u otra. Ya sea que esté creando nuevos documentos y agregándolos a colecciones, recuperando documentos, actualizando datos o eliminando elementos obsoletos, los documentos están en el centro del modelo MongoDB.

En esta guía, cubriremos qué son los documentos de MongoDB y luego cubriremos las operaciones comunes que probablemente necesitará conocer para administrar un entorno centrado en documentos.

¿Qué son los documentos MongoDB?

En MongoDB, todos los datos dentro de las bases de datos y las colecciones se almacenan en documentos. Dado que las colecciones no especifican un esquema obligatorio de forma predeterminada, los documentos dentro de una colección pueden contener una estructura arbitrariamente compleja y no es necesario que coincidan con el formato utilizado por los documentos hermanos. Esto proporciona una flexibilidad increíble y permite que el esquema se desarrolle orgánicamente a medida que cambian los requisitos de la aplicación.

Los propios documentos de MongoDB utilizan el formato de serialización de datos BSON, una representación binaria de la notación de objetos JSON JavaScript. Esto proporciona una estructura organizada con tipos de datos definidos que se pueden consultar y operar mediante programación.

Los documentos BSON están representados por un par de llaves ({} ) que contienen pares clave-valor. En BSON, estas parejas de datos se conocen como el campo y su valor . El campo viene primero y está representado por una cadena. El valor puede ser cualquier tipo de datos BSON válido. Dos puntos (: ) separa el campo de su valor. Se utiliza una coma para separar cada par de campos y valores entre sí.

Como ejemplo, aquí hay un documento BSON válido que MongoDB puede entender:

{    _id: 80380,    vehicle_type: "car",    mileage: 7377.80,    color: "blue",    markets: [        "US",        "UK"    ],    options: {        transmission: "automatic",        num_doors: 4,        power_windows: true    }}
 

Aquí, podemos ver bastantes tipos:

• _id es un entero
• vehicle_type y color son cadenas
• mileage es un flotador
• markets es una matriz de cadenas
• options contiene un documento anidado con valores que consisten en una cadena, un entero y un booleano

Debido a esta flexibilidad, los documentos son un medio bastante flexible para almacenar datos. Los nuevos campos se pueden agregar fácilmente, los documentos se pueden incrustar entre sí y la complejidad estructural coincide exactamente con los datos que se almacenan.

Cómo crear nuevos documentos

Para crear un nuevo documento, cambie a una base de datos donde desee almacenar el documento creado. Usaremos una school base de datos con fines de demostración en este artículo:

use school
 

También querrá elegir la colección en la que desea insertar los documentos. Al igual que con las bases de datos, no tiene que crear explícitamente la colección donde desea insertar el documento. MongoDB lo creará automáticamente cuando se escriban los primeros datos. Para este ejemplo, usaremos una colección llamada students .

Ahora que sabe dónde se almacenará el documento, puede insertar uno nuevo usando uno de los siguientes métodos.

Usando insert() método

El insert() El método le permite insertar uno o más documentos en la colección a la que se llama.

Para insertar un solo documento, pase el documento al método invocándolo en la colección. Aquí, insertamos un nuevo documento para un estudiante llamado Ashley:

db.students.insert(    {        first_name: "Ashley",        last_name: "Jenkins",        dob: new Date("January 08, 2003"),        grade_level: 8    })
 

WriteResult({ "nInserted" : 1 })
 

Si desea insertar más de un documento al mismo tiempo, en lugar de pasar un documento a insert() , pasar una serie de documentos. Podemos agregar dos documentos nuevos para los estudiantes llamados Brian y Leah:

db.students.insert(    [        {            first_name: "Brian",            last_name: "McMantis",            dob: new Date("September 18, 2010"),            grade_level: 2        },        {            first_name: "Leah",            last_name: "Drake",            dob: new Date("October 03, 2009")        }    ])
 

BulkWriteResult({        "writeErrors" : [ ],        "writeConcernErrors" : [ ],        "nInserted" : 2,        "nUpserted" : 0,        "nMatched" : 0,        "nModified" : 0,        "nRemoved" : 0,        "upserted" : [ ]})
 

Dado que realizamos una operación de escritura masiva, nuestro valor de retorno es un BulkWriteResult en lugar de WriteResult objeto que vimos antes.

Mientras que insert() El método es flexible, ha quedado obsoleto en muchos controladores MongoDB a favor de los siguientes dos métodos.

Usando insertOne() método

El insertOne() El método se puede utilizar para insertar un solo documento. A diferencia de insert() método, solo puede insertar un documento a la vez, lo que hace que su comportamiento sea un poco más predecible.

La sintaxis es la misma que cuando usa insert() para agregar un solo documento. Podemos agregar otro estudiante llamado Naomi:

db.students.insertOne(    {        first_name: "Naomi",        last_name: "Pyani"    })
 

{        "acknowledged" : true,        "insertedId" : ObjectId("60e877914655cbf49ff7cb86")}
 

A diferencia de insert() , el insertOne() El método devuelve un documento que contiene información útil adicional. Confirma que el clúster reconoció la escritura e incluye el ID de objeto que se asignó al documento, ya que no proporcionamos uno.

Usando insertMany() método

Para cubrir escenarios en los que desea insertar varios documentos a la vez, insertMany() ahora se recomienda el método. Al igual que cuando se insertan varios documentos con insert() , insertMany() toma una serie de documentos.

Podemos agregar tres nuevos estudiantes llamados Jasmine, Michael y Toni:

db.students.insertMany(    [        {            first_name: "Jasmine",            last_name: "Took",            dob: new Date("April 11, 2011")        },        {            first_name: "Michael",            last_name: "Rodgers",            dob: new Date("February 25, 2008"),            grade_level: 6        },        {            first_name: "Toni",            last_name: "Fowler"        }    ])
 

{        "acknowledged" : true,        "insertedIds" : [                ObjectId("60e8792d4655cbf49ff7cb87"),                ObjectId("60e8792d4655cbf49ff7cb88"),                ObjectId("60e8792d4655cbf49ff7cb89")        ]}
 

Al igual que con insertOne() , insertMany() devuelve un documento que reconoce la escritura y proporciona una matriz que contiene los ID que se han asignado a los documentos insertados.

Cómo consultar documentos existentes

La consulta de documentos es un tema bastante amplio que merece su propio artículo. Puede encontrar detalles sobre cómo formular consultas para recuperar diferentes tipos de documentos en nuestra guía sobre cómo consultar datos dentro de MongoDB.

Si bien es mejor dejar los detalles en el artículo vinculado anteriormente, al menos podemos cubrir los métodos que proporciona MongoDB para consultar documentos. La forma principal de obtener documentos de MongoDB es llamando a find() en la colección en cuestión.

Por ejemplo, para recopilar todos los documentos de los students , puede llamar a find() sin argumentos:

db.students.find()
 

{ "_id" : ObjectId("60e8743b4655cbf49ff7cb83"), "first_name" : "Ashley", "last_name" : "Jenkins", "dob" : ISODate("2003-01-08T00:00:00Z"), "grade_level" : 8 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb84"), "first_name" : "Brian", "last_name" : "McMantis", "dob" : ISODate("2010-09-18T00:00:00Z"), "grade_level" : 2 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb85"), "first_name" : "Leah", "last_name" : "Drake", "dob" : ISODate("2009-10-03T00:00:00Z") }{ "_id" : ObjectId("60e877914655cbf49ff7cb86"), "first_name" : "Naomi", "last_name" : "Pyani" }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb87"), "first_name" : "Jasmine", "last_name" : "Took", "dob" : ISODate("2011-04-11T00:00:00Z") }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb88"), "first_name" : "Michael", "last_name" : "Rodgers", "dob" : ISODate("2008-02-25T00:00:00Z"), "grade_level" : 6 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }
 

Para que la salida sea más legible, también puede encadenar pretty() método después de find() :

db.<collection>.find().pretty()
 

{        "_id" : ObjectId("60e8743b4655cbf49ff7cb83"),        "first_name" : "Ashley",        "last_name" : "Jenkins",        "dob" : ISODate("2003-01-08T00:00:00Z"),        "grade_level" : 8}{        "_id" : ObjectId("60e875d54655cbf49ff7cb84"),        "first_name" : "Brian",        "last_name" : "McMantis",        "dob" : ISODate("2010-09-18T00:00:00Z"),        "grade_level" : 2}{        "_id" : ObjectId("60e875d54655cbf49ff7cb85"),        "first_name" : "Leah",        "last_name" : "Drake",        "dob" : ISODate("2009-10-03T00:00:00Z")}{        "_id" : ObjectId("60e877914655cbf49ff7cb86"),        "first_name" : "Naomi",        "last_name" : "Pyani"}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb87"),        "first_name" : "Jasmine",        "last_name" : "Took",        "dob" : ISODate("2011-04-11T00:00:00Z")}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb88"),        "first_name" : "Michael",        "last_name" : "Rodgers",        "dob" : ISODate("2008-02-25T00:00:00Z"),       "grade_level" : 6}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb89"),        "first_name" : "Toni",        "last_name" : "Fowler"}
 

Puedes ver que un _id Se ha añadido un campo a cada uno de los documentos. MongoDB requiere un _id único para cada documento de una colección. Si no proporciona uno al crear el objeto, agregará uno por usted. Puede utilizar este ID para recuperar un único objeto de forma fiable:

db.students.find(    {        _id : ObjectId("60e8792d4655cbf49ff7cb89")    })
 

{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }
 

Puede obtener más información sobre varias formas de consultar datos con el artículo vinculado anteriormente.

Cómo actualizar documentos existentes

Muchos o la mayoría de los casos de uso de las bases de datos requieren que pueda modificar los datos existentes dentro de la base de datos. Es posible que deba actualizar un campo para reflejar un nuevo valor o que deba agregar información adicional a un documento existente a medida que esté disponible.

MongoDB utiliza algunos métodos relacionados para actualizar documentos existentes:

• updateOne() :actualiza un solo documento dentro de una colección según el filtro proporcionado.
• updateMany() :actualiza varios documentos dentro de una colección que coinciden con el filtro proporcionado.
• replaceOne() :reemplaza un documento completo en una colección según el filtro provisto.

Cubriremos cómo usar cada una de estas variedades para realizar diferentes tipos de actualizaciones.

Operadores de actualización

Antes de echar un vistazo a cada uno de los métodos para actualizar documentos, debemos repasar algunos de los operadores de actualización que están disponibles.

• $currentDate :Establece el valor de un campo en la fecha actual, ya sea como fecha o tipo de marca de tiempo.
  • Sintaxis:{ $currentDate: { <field>: <type>, ... } }
• $inc :Incrementa el valor de un campo en una cantidad establecida.
  • Sintaxis:{ $inc: { <field>: <amount>, ... } }
• $min :Actualiza el valor de un campo si el valor especificado es menor que el valor actual.
  • Sintaxis:{ $min: { <field>: <value>, ... } }
• $max :Actualiza el valor de un campo si el valor especificado es mayor que el valor actual.
  • Sintaxis:{ $max: { <field>: <value>, ... } }
• $mul :Actualiza el valor de un campo multiplicándolo por el número dado.
  • Sintaxis:{ $mul: { <field>: <value>, ... } }
• $rename :Cambia el nombre de un campo a un nuevo identificador.
  • Sintaxis:{ $rename: { <field>: <new_name>, ... } }
• $set :Reemplaza el valor de un campo con el valor dado.
  • Sintaxis:{ $set: { <field>: value, ... } }
• $setOnInsert :Durante las operaciones upsert, establece el valor de un campo si se está creando un nuevo documento y no hace nada en caso contrario.
  • Sintaxis:{ $setOnInsert: { <field>: <value>, ... } }
• $unset :Elimina un campo del documento.
  • Sintaxis:{ $unset: { <field>: "", ... } }
• $ :Un marcador de posición para el primer elemento de la matriz que satisface la consulta.
  • Sintaxis:{ <update_operator>: {<array>.$: <value> } }
• $[] :Un marcador de posición para todos los elementos de la matriz que satisfacen la consulta.
  • Sintaxis:{ <update_operator>: { <array>.$[]: <value> } }
• $addToSet :Agrega valores a la matriz a menos que ya estén presentes.
  • Sintaxis:{ $addToSet: { <field>: <value>, ... } }
• $pop :Elimina el primer o último elemento de una matriz.
  • Sintaxis:{ $pop: { <field>: (-1 or 1), ... } }
• $pull :elimina todos los elementos de una matriz que coincidan con una condición.
  • Sintaxis:{ $pull: { <field>: <condition>, ... } }
• $push :Agrega un valor a una matriz.
  • Sintaxis:{ $push: { <field>: <value>, ... } }
• $pullAll :Elimina todos los elementos especificados de una matriz.
  • Sintaxis:{ $pullAll: { <field>: [ <value>, ... ], ...} }
• $each :Modifica $addToSet y $push operadores para que agreguen cada elemento de una matriz en lugar de una matriz como un solo elemento.
  • Sintaxis:{ <update_operator>: { <field>: { $each: [ <value>, ... ] }, ... } }
• $position :Usado con $each y especifica la posición del $push el operador debe insertar at.
  • Sintaxis:{ $push: { <field>: { $each: [ <value>, ... ], $position: <num> } } }
• $slice :Usado con $each y $push para limitar el número de elementos totales en la matriz.
  • Sintaxis:{ $push: { <field>: { $each: [ <value>, ... ], $slice: <num> } } }
• $sort :Usado con $each y $push para ordenar los elementos de la matriz.
  • Sintaxis:{ $push: { <field>: { $each: [ <value>, ... ], $sort: <sort_order> } } }

Estos diversos operadores de actualización le permiten actualizar varios campos de sus documentos de diferentes maneras.

Actualizar un solo documento en una coleccion

updateOne() de MongoDB El método se utiliza para actualizar un solo documento dentro de una colección. El método toma dos argumentos obligatorios, así como un documento que especifica argumentos opcionales.

El primer argumento es un documento que especifica las condiciones de filtro que se utilizarán para seleccionar documentos. Desde el updateOne() modifica como máximo un documento en una colección, se utilizará el primer documento que satisfaga las condiciones del filtro.

El segundo argumento especifica la operación de actualización que debe ejecutarse. Las operaciones de actualización proporcionadas anteriormente se pueden especificar aquí para modificar el contenido del documento coincidente.

El tercer argumento es un documento de varias opciones para modificar el comportamiento del método. Los valores potenciales más importantes son:

• upsert :Convierte la operación en un procedimiento upsert insertando un nuevo documento si el filtro no coincide con ningún documento existente.
• collation :Un documento que define las reglas específicas del idioma que deben aplicarse para la operación.

Como ejemplo, podemos actualizar un solo registro de estudiante que filtramos por el _id para asegurarnos de que apuntamos al documento correcto. Podemos establecer el grade_level a un nuevo valor:

db.students.updateOne(    { _id: ObjectId("60e8792d4655cbf49ff7cb89") },    { $set: { grade_level: 3 } })
 

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
 

Actualizar varios documentos en una colección

updateMany() de MongoDB El método funciona de manera similar a updateOne() pero en su lugar actualiza cualquier documento que coincida con el filtro dado en lugar de detenerse después de la primera coincidencia.

El updateMany() la sintaxis sigue exactamente el updateOne() sintaxis, por lo que la única diferencia es el alcance de la operación.

Como ejemplo, si queremos cambiar todas las instancias de "composición" a "escritura" en los subjects matriz en nuestros teachers documentos de colección, podríamos usar algo como esto:

db.teachers.updateMany(    { subject: "composition" },    { $set: { "subjects.$": "writing" } })
 

{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
 

Si revisa los documentos, cada instancia de "composición" debería haber sido reemplazada por "escritura":

db.teachers.find()
 

{ "_id" : ObjectId("60eddca65eb74f5c676f3baa"), "first_name" : "Nancy", "last_name" : "Smith", "subjects" : [ "vocabulary", "pronunciation" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bab"), "first_name" : "Ronald", "last_name" : "Taft", "subjects" : [ "literature", "grammar", "writing" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bac"), "first_name" : "Casey", "last_name" : "Meyers", "subjects" : [ "literature", "writing", "grammar" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bad"), "first_name" : "Rebecca", "last_name" : "Carrie", "subjects" : [ "grammar", "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bae"), "first_name" : "Sophie", "last_name" : "Daggs", "subjects" : [ "literature", "writing", "grammar", "vocabulary", "pronunciation" ] }
 

Reemplazar un documento

El replaceOne() El método funciona de manera similar a updateOne() pero reemplaza todo el documento en lugar de actualizar campos individuales. La sintaxis es la misma que la de los dos comandos anteriores.

Por ejemplo, si Nancy Smith deja su escuela y la reemplaza con una maestra llamada Clara Newman que enseña literatura, podría escribir lo siguiente:

db.teachers.replaceOne(    {        $and: [             { first_name: "Nancy" },            { last_name: "Smith" }        ]    },    {        first_name: "Clara",        last_name: "Newman",        subjects: [ "literature" ]    })
 

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
 

Puede ver que el documento coincidente se eliminó y que el documento especificado lo reemplazó:

db.teachers.find()
 

{ "_id" : ObjectId("60eddca65eb74f5c676f3baa"), "first_name" : "Clara", "last_name" : "Newman", "subjects" : [ "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bab"), "first_name" : "Ronald", "last_name" : "Taft", "subjects" : [ "literature", "grammar", "writing" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bac"), "first_name" : "Casey", "last_name" : "Meyers", "subjects" : [ "literature", "writing", "grammar" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bad"), "first_name" : "Rebecca", "last_name" : "Carrie", "subjects" : [ "grammar", "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bae"), "first_name" : "Sophie", "last_name" : "Daggs", "subjects" : [ "literature", "writing", "grammar", "vocabulary", "pronunciation" ] }
 

Cómo eliminar documentos

La eliminación de documentos de las colecciones también forma parte del ciclo de vida del documento. Para eliminar un documento, puede usar deleteOne() o deleteMany() métodos. Tienen la misma sintaxis y solo difieren en la cantidad de documentos en los que operan.

En su mayor parte, todo lo que tiene que hacer para eliminar documentos con cualquiera de estos métodos es proporcionarle un documento de filtro que especifique cómo desea seleccionar el documento que desea eliminar. El deleteOne() eliminará como máximo un documento (independientemente de cuántas coincidencias produzca el filtro) mientras que deleteMany() El método elimina todos los documentos que coincidan con las condiciones del filtro.

Por ejemplo, para eliminar un solo estudiante, puede proporcionar un _id para hacerlos coincidir explícitamente:

db.students.deleteOne({    _id: ObjectId("60e8792d4655cbf49ff7cb87")})
 

{ "acknowledged" : true, "deletedCount" : 1 }
 

Si queremos eliminar a algún estudiante que no tenga un nivel de grado asignado, podemos usar el deleteMany() método en su lugar:

db.students.deleteMany({    grade_level: { $eq: null }})
 

{ "acknowledged" : true, "deletedCount" : 2 }
 

Si marcamos, deberíamos ver que todos los estudiantes restantes tienen un nivel de grado asignado:

db.students.find()
 

{ "_id" : ObjectId("60e8743b4655cbf49ff7cb83"), "first_name" : "Ashley", "last_name" : "Jenkins", "dob" : ISODate("2003-01-08T00:00:00Z"), "grade_level" : 8 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb84"), "first_name" : "Brian", "last_name" : "McMantis", "dob" : ISODate("2010-09-18T00:00:00Z"), "grade_level" : 2 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb88"), "first_name" : "Michael", "last_name" : "Rodgers", "dob" : ISODate("2008-02-25T00:00:00Z"), "grade_level" : 6 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler", "grade_level" : 3 }
 

Conclusión

Aprender a crear, consultar, actualizar y eliminar documentos le brinda las habilidades que necesita para administrar documentos de manera efectiva dentro de MongoDB a diario. Familiarizarse con los diversos documentos y métodos de recopilación y los operadores que le permiten unir y modificar información le permite expresar pensamientos complejos que el sistema de base de datos puede entender.