Actualizar registros de MongoDB

Introducción

En este laboratorio, aprenderás cómo actualizar registros de MongoDB utilizando diversas técnicas, incluyendo la actualización de un solo documento, la realización de actualizaciones masivas y el uso de operadores de actualización. También explorarás cómo manejar los resultados de las actualizaciones y verificar los datos actualizados. Este laboratorio cubre las operaciones CRUD (Crear, Leer, Actualizar, Eliminar) fundamentales en MongoDB, brindándote las habilidades necesarias para administrar eficazmente tus datos en una base de datos MongoDB.

El laboratorio comienza demostrando cómo actualizar un solo documento utilizando el método updateOne(), seguido de la exploración de actualizaciones masivas con el método updateMany(). Luego, profundizarás en el uso de operadores de actualización, como $set, para modificar campos específicos dentro de los documentos. Además, aprenderás cómo manejar los resultados de las actualizaciones y verificar los datos actualizados para garantizar la integridad de tus registros de MongoDB.

Skills Graph

Actualizar un solo documento

En este paso, aprenderás cómo actualizar un solo documento en MongoDB utilizando el método updateOne(). Continuaremos trabajando con nuestra colección de libros y demostraremos cómo modificar atributos específicos de un documento.

Primero, conectémonos a la shell de MongoDB y cambiemos a la base de datos mylab_database:

mongosh
use mylab_database

Para comenzar, veamos los libros actuales en nuestra colección:

db.books.find()

Deberías ver la lista de libros que agregamos anteriormente:

[
  {
    _id: ObjectId('674681ac7b1f6d3a37c1c18c'),
    title: 'JavaScript Fundamentals',
    author: 'Mike Johnson',
    year: 2022,
    pages: 350
  },
  {
    _id: ObjectId('674681ac7b1f6d3a37c1c18d'),
    title: 'Python Deep Dive',
    author: 'Sarah Williams',
    year: 2021,
    pages: 450
  },
  {
    _id: ObjectId('674681ac7b1f6d3a37c1c18e'),
    title: 'Machine Learning Basics',
    author: 'John Doe',
    year: 2020,
    price: 39.99
  }
]

Ahora, usaremos el método updateOne() para modificar un documento específico. Actualizaremos el libro "JavaScript Fundamentals" para cambiar su número de páginas:

db.books.updateOne(
    { title: "JavaScript Fundamentals" },
    { $set: { pages: 400 } }
)

Desglosemos este comando:

• El primer argumento { title: "JavaScript Fundamentals" } es el filtro que encuentra el documento específico a actualizar.
• $set es un operador de actualización que cambia el valor de un campo específico.
• { pages: 400 } establece el nuevo número de páginas en 400.

Para verificar la actualización, encontraremos el documento nuevamente:

db.books.find({ title: "JavaScript Fundamentals" })

Deberías ver el documento con el número de páginas actualizado a 400.

Realizar actualizaciones masivas

En este paso, aprenderás cómo realizar actualizaciones masivas en MongoDB utilizando el método updateMany(). Las actualizaciones masivas son muy útiles cuando necesitas modificar múltiples documentos que coincidan con una condición específica.

Vamos a agregar algunos libros más a nuestra colección para demostrar las actualizaciones masivas:

db.books.insertMany([
    {
        title: "Advanced Python",
        author: "John Doe",
        year: 2019,
        price: 44.99
    },
    {
        title: "Data Science Handbook",
        author: "Jane Smith",
        year: 2021,
        price: 49.99
    }
])

Ahora, realicemos una actualización masiva para aumentar el precio de todos los libros de John Doe en $10:

db.books.updateMany(
    { author: "John Doe" },
    { $inc: { price: 10 } }
)

Desglosemos este comando:

• { author: "John Doe" } selecciona todos los libros de John Doe.
• $inc es un operador de actualización que incrementa el campo especificado.
• { price: 10 } aumenta el precio en 10.

Verifica la actualización encontrando todos los libros de John Doe:

db.books.find({ author: "John Doe" })

Deberías ver que los precios de "Machine Learning Basics" y "Advanced Python" han aumentado en $10.

Realicemos otra actualización masiva agregando una categoría a todos los libros publicados antes de 2021:

db.books.updateMany(
    { year: { $lt: 2021 } },
    { $set: { category: "Older Publication" } }
)

Aquí, $lt significa "menor que", actualizando todos los libros publicados antes de 2021 agregando una categoría "Older Publication".

Usar operadores de actualización

En este paso, explorarás poderosos operadores de actualización de MongoDB que te permiten realizar modificaciones complejas de documentos más allá de simples cambios de valor.

Primero, creemos algunos datos de muestra con los que trabajar:

db.products.insertMany([
    {
        name: "Laptop",
        price: 1000,
        tags: ["electronics", "computer"],
        stock: 50
    },
    {
        name: "Smartphone",
        price: 800,
        tags: ["electronics", "mobile"],
        stock: 30
    }
])

MongoDB proporciona varios operadores de actualización poderosos que te permiten modificar documentos de manera sofisticada:

1. Operador $mul - Multiplicar valores numéricos

db.products.updateOne(
    { name: "Laptop" },
    { $mul: { price: 1.1 } }
)

La salida:

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0,
  upsertedId: null
}

El operador $mul multiplica el valor de un campo por el número especificado. En este ejemplo, estamos aumentando el precio de la laptop en un 10%.

2. Operador $push - Agregar elementos a un array

db.products.updateOne(
    { name: "Smartphone" },
    { $push: { tags: "sale" } }
)

La salida:

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0,
  upsertedId: null
}

El operador $push agrega un elemento a un campo de tipo array. Aquí, estamos agregando una etiqueta "sale" a las etiquetas del smartphone.

3. Operadores $min y $max - Actualizar basado en comparación

db.products.updateOne(
    { name: "Laptop" },
    {
        $min: { stock: 40 },
        $max: { price: 1200 }
    }
)

La salida:

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0,
  upsertedId: null
}

• $min actualiza el campo si el valor especificado es menor que el valor existente.
• $max actualiza el campo si el valor especificado es mayor que el valor existente.

Verifiquemos nuestras actualizaciones:

db.products.find()

[
  {
    _id: ObjectId('674683aebec38876f7c1c18e'),
    name: 'Laptop',
    price: 1200,
    tags: [ 'electronics', 'computer' ],
    stock: 40
  },
  {
    _id: ObjectId('674683aebec38876f7c1c18f'),
    name: 'Smartphone',
    price: 800,
    tags: [ 'electronics', 'mobile', 'sale' ],
    stock: 30
  }
]

Deberías ver los documentos modificados con los precios, etiquetas y niveles de stock actualizados.

Manejar los resultados de las actualizaciones

En este paso, aprenderás cómo manejar e interpretar los resultados de las operaciones de actualización en MongoDB. Comprender los resultados de las actualizaciones te ayuda a verificar que tus actualizaciones fueron exitosas y a entender su impacto.

Vamos a crear algunos datos de muestra con los que trabajar:

db.users.insertMany([
    { name: "Alice", age: 28, status: "active" },
    { name: "Bob", age: 35, status: "inactive" },
    { name: "Charlie", age: 42, status: "active" }
])

Ahora, exploremos diferentes propiedades de los resultados de actualización:

1. Resultado básico de actualización

const result = db.users.updateOne(
    { name: "Alice" },
    { $set: { age: 29 } }
)

print("Matched Documents: " + result.matchedCount)
print("Modified Documents: " + result.modifiedCount)

La salida:

Matched Documents: 1
Modified Documents: 1

El objeto de resultado proporciona dos propiedades clave:

• matchedCount: Número de documentos que coinciden con el filtro.
• modifiedCount: Número de documentos realmente modificados.

Esto te ayuda a entender exactamente lo que sucedió durante la operación de actualización. Si matchedCount es 0, no se encontraron documentos. Si modifiedCount es 0, no se hicieron cambios incluso si se encontró un documento.

2. Operación de upsert

db.users.updateOne(
    { name: "David" },
    { $set: { name: "David", age: 25, status: "active" } },
    { upsert: true }
)

Un upsert crea un nuevo documento si no se encuentra ningún documento coincidente:

3. Resultados de actualización masiva

db.users.updateMany(
    { status: "active" },
    { $inc: { age: 1 } }
)

Esto demuestra cómo obtener resultados de una operación de actualización masiva, mostrando cuántos usuarios activos se coincidieron y modificaron.

Verifiquemos nuestras actualizaciones:

db.users.find()

Verificar los datos actualizados

En este paso, aprenderás varios métodos para verificar y consultar los datos actualizados en MongoDB. Confirmar tus actualizaciones es crucial para mantener la integridad de los datos y asegurarte de que tus modificaciones se apliquen correctamente.

Vamos a crear algunos datos de muestra para explorar técnicas de verificación:

db.inventory.insertMany([
    {
        item: "laptop",
        quantity: 25,
        status: "available",
        category: "electronics"
    },
    {
        item: "smartphone",
        quantity: 15,
        status: "low stock",
        category: "mobile"
    }
])

1. Consulta de coincidencia exacta para una verificación precisa

db.inventory.updateOne(
    { item: "laptop" },
    { $set: { quantity: 30 } }
)

const laptopUpdate = db.inventory.findOne({
    item: "laptop",
    quantity: 30
})

print("Laptop Update Verified: " + (laptopUpdate!== null))

La salida:

Laptop Update Verified: true

Este método comprueba si existe un documento con exactamente los valores actualizados. Es la forma más directa de confirmar una actualización específica.

2. Verificación basada en rangos

db.inventory.updateMany(
    { status: "low stock" },
    { $inc: { quantity: 5 } }
)

const updatedItems = db.inventory.find({
    quantity: { $gte: 20 }
}).toArray()

print("Updated Low Stock Items: " + updatedItems.length)

La salida:

Updated Low Stock Items: 2

Usar operadores de comparación como $gte (mayor o igual que) te permite verificar actualizaciones en múltiples documentos.

3. Verificación de consulta compleja

db.inventory.updateOne(
    { item: "smartphone" },
    { $set: { status: "in stock" } }
)

const verifyUpdate = db.inventory.findOne({
    item: "smartphone",
    status: "in stock",
    category: "mobile"
})

print("Smartphone Status Updated: " + (verifyUpdate!== null))

La salida:

Smartphone Status Updated: true

Esto demuestra una verificación más compleja que comprueba múltiples condiciones simultáneamente.

Veamos todos los documentos para confirmar nuestras actualizaciones:

db.inventory.find()

Resumen

En este laboratorio, aprendiste cómo actualizar documentos individuales y múltiples en una base de datos MongoDB. Comenzaste utilizando el método updateOne() para modificar un documento específico, cambiando el número de páginas del libro "JavaScript Fundamentals". Luego, exploraste cómo realizar actualizaciones masivas con el método updateMany(), lo que te permitió modificar múltiples documentos que coincidieran con una condición específica. Además, aprendiste sobre varios operadores de actualización, como $set, que utilizaste para cambiar los valores de los campos. Finalmente, verificaste los datos actualizados para asegurarte de que los cambios se aplicaran correctamente.