Manejar Arrays en MongoDB

Introducción

En este laboratorio, aprenderá a manejar arrays en MongoDB. Los arrays son una estructura de datos fundamental en MongoDB que le permiten almacenar listas de valores dentro de un único documento. Explorará varias operaciones, incluyendo la creación de documentos con campos de array, la adición y eliminación de elementos, la actualización de valores dentro de arrays y la realización de consultas basadas en el contenido de los arrays. Estas habilidades son esenciales para gestionar estructuras de datos complejas de manera efectiva en MongoDB.

Al final de este laboratorio, tendrá una comprensión sólida y práctica de cómo trabajar con arrays en MongoDB, lo que le permitirá construir esquemas de bases de datos más sofisticados y flexibles.

Crear Documentos con Campos de Array

En este primer paso, se conectará al servidor de MongoDB y creará un nuevo documento que incluye un campo de array. Los arrays son potentes porque le permiten almacenar múltiples valores relacionados, como etiquetas, comentarios o cursos, directamente dentro de un documento.

Primero, abra la shell de MongoDB para comenzar a interactuar con su base de datos. Realizará todas las operaciones subsiguientes en este laboratorio dentro de la shell mongosh.

mongosh

Una vez dentro de la shell, verá un prompt como test>. Cambiemos a la base de datos arraylab, que ha sido preconfigurada para este laboratorio.

use arraylab

El script setup ya ha creado una colección students e insertado un documento. Ahora, insertará un nuevo documento para un estudiante llamado "Alice Johnson". Este documento tendrá un campo courses, que es un array de cadenas de texto.

db.students.insertOne({
    name: "Alice Johnson",
    age: 22,
    courses: ["Mathematics", "Computer Science", "Physics"]
})

Este comando inserta un único documento en la colección students. El campo courses contiene un array con tres elementos de tipo cadena.

Para confirmar que el documento se creó correctamente, puede usar el método find() para recuperar todos los documentos de la colección. El método .pretty() formatea la salida para que sea más legible.

db.students.find().pretty()

Debería ver dos documentos: el de "Bob Smith" que se creó durante la configuración y el documento de "Alice Johnson" que acaba de agregar.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Chess Club', 'Debate Team' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Physics' ]
  }
]

Añadir Elementos a un Array

Después de crear arrays, una tarea común es añadirles nuevos elementos. En este paso, aprenderá a usar el operador $push para añadir elementos al final de un array existente.

Para añadir un único elemento a un array, use el operador $push en una operación de actualización. Añadamos un nuevo curso, "Data Science", a la lista de cursos de Alice Johnson.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $push: { courses: "Data Science" } }
)

En este comando, el primer argumento { name: "Alice Johnson" } es el filtro que encuentra el documento a actualizar. El segundo argumento { $push: { courses: "Data Science" } } especifica la acción de actualización. $push añade el valor "Data Science" al array courses.

Verifiquemos el cambio buscando de nuevo el documento de Alice.

db.students.find({ name: "Alice Johnson" }).pretty()

La salida muestra el nuevo curso añadido al array.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Physics', 'Data Science' ]
  }
]

Para añadir múltiples elementos a la vez, puede combinar $push con el modificador $each. Añadamos dos nuevas actividades para Bob Smith.

db.students.updateOne(
    { name: "Bob Smith" },
    { $push: { activities: { $each: ["Robotics Club", "Swimming Team"] } } }
)

Aquí, $each indica a $push que añada cada elemento de la lista proporcionada (["Robotics Club", "Swimming Team"]) al array activities.

Verifique también esta actualización:

db.students.find({ name: "Bob Smith" }).pretty()

La salida confirma que se han añadido ambas nuevas actividades.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Chess Club', 'Debate Team', 'Robotics Club', 'Swimming Team' ]
  }
]

Eliminar Elementos de un Array

Así como puedes añadir elementos, también necesitas poder eliminarlos. MongoDB proporciona varios operadores para este propósito. En este paso, aprenderás a usar $pull para eliminar elementos por valor y $pop para eliminarlos por posición.

Para eliminar un elemento específico de un array basándote en su valor, usa el operador $pull. Eliminemos "Physics" de la lista de cursos de Alice.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pull: { courses: "Physics" } }
)

Este comando busca el documento de Alice y elimina todas las ocurrencias de "Physics" de su array courses. Comprueba el resultado:

db.students.find({ name: "Alice Johnson" }).pretty()

La salida muestra que "Physics" ya no está en el array.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Data Science' ]
  }
]

Para eliminar múltiples elementos que coinciden con valores en una lista, puedes usar el operador $pullAll. Eliminemos tanto "Chess Club" como "Debate Team" de las actividades de Bob.

db.students.updateOne(
    { name: "Bob Smith" },
    { $pullAll: { activities: ["Chess Club", "Debate Team"] } }
)

Verifica la actualización del documento de Bob:

db.students.find({ name: "Bob Smith" }).pretty()

La salida confirma la eliminación de las actividades especificadas.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Robotics Club', 'Swimming Team' ]
  }
]

Si necesitas eliminar un elemento del principio o del final de un array, puedes usar el operador $pop. Usa 1 para eliminar el último elemento y -1 para eliminar el primero. Eliminemos el último curso de la lista de Alice.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pop: { courses: 1 } }
)

Veamos el estado final de los cursos de Alice:

db.students.find({ name: "Alice Johnson" }).pretty()

La salida muestra que el último elemento, "Data Science", ha sido eliminado.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science' ]
  }
]

Actualizar Elementos en un Array

Actualizar elementos existentes dentro de un array es otra operación crucial. Este paso cubre cómo actualizar elementos de array utilizando operadores posicionales.

Para actualizar un único elemento específico en un array, primero debes hacer coincidir el documento y el elemento que deseas cambiar. Luego, puedes usar el operador posicional $ para realizar la actualización. Cambiemos "Mathematics" por "Advanced Mathematics" en el array courses de Alice.

db.students.updateOne(
    { name: "Alice Johnson", courses: "Mathematics" },
    { $set: { "courses.$": "Advanced Mathematics" } }
)

En este comando, el filtro { name: "Alice Johnson", courses: "Mathematics" } encuentra el documento e identifica la posición de la primera ocurrencia de "Mathematics" en el array. La actualización { $set: { "courses.$": "Advanced Mathematics" } } utiliza courses.$ para referirse a la posición de ese elemento coincidente y establece su nuevo valor.

Verifica el cambio:

db.students.find({ name: "Alice Johnson" }).pretty()

La salida muestra el nombre del curso actualizado.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Advanced Mathematics', 'Computer Science' ]
  }
]

Para actualizar todos los elementos de un array que coinciden con una condición, puedes usar el operador posicional $[ ]. Incrementemos todas las calificaciones de Bob en 5 puntos usando el operador $inc (incrementar).

db.students.updateOne(
    { name: "Bob Smith" },
    { $inc: { "grades.$[]": 5 } }
)

Aquí, grades.$[] aplica la operación $inc a cada elemento del array grades.

Verifica las nuevas calificaciones de Bob:

db.students.find({ name: "Bob Smith" }).pretty()

La salida muestra que cada calificación se ha incrementado en 5.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 100, 92, 97 ],
    activities: [ 'Robotics Club', 'Swimming Team' ]
  }
]

Consultar Documentos Basados en Contenido de Array

La consulta es el corazón de cualquier base de datos. MongoDB ofrece un rico conjunto de operadores para consultar documentos basándose en el contenido de sus arrays. En este paso final, aprenderás a encontrar documentos coincidiendo con elementos de array y sus propiedades.

Para encontrar todos los documentos donde un array contiene un elemento específico, puedes incluir ese valor en tu filtro de consulta. Busquemos todos los estudiantes inscritos en "Computer Science".

db.students.find({ courses: "Computer Science" }).pretty()

Esta consulta devolverá el documento de Alice, ya que su array courses contiene "Computer Science".

Para encontrar documentos donde un array contiene todos los elementos de un conjunto especificado, usa el operador $all.

db.students.find({
    courses: { $all: ["Advanced Mathematics", "Computer Science"] }
}).pretty()

Esto también devolverá el documento de Alice porque su array courses contiene ambos valores.

Para condiciones más complejas en elementos de array, el operador $elemMatch es muy útil. Permite especificar múltiples criterios que un solo elemento del array debe cumplir. Busquemos estudiantes que tengan al menos una calificación mayor a 95.

db.students.find({
    grades: { $elemMatch: { $gt: 95 } }
}).pretty()

Esta consulta devolverá el documento de Bob, ya que ahora tiene calificaciones superiores a 95. $gt significa "greater than" (mayor que).

También puedes consultar basándote en el número de elementos en un array usando el operador $size. Busquemos estudiantes que estén en exactamente dos actividades.

db.students.find({
    activities: { $size: 2 }
}).pretty()

Esto devolverá el documento de Bob, ya que su array activities actualmente tiene dos elementos.

Finalmente, agreguemos un estudiante más para practicar una consulta combinada.

db.students.insertOne({
    name: "Charlie Brown",
    courses: ["Art", "Music", "Literature"],
    grades: [88, 92, 85],
    activities: ["Painting Club"]
})

Ahora, busquemos estudiantes que estén cursando "Art" o "Music" (usando el operador $in) Y que tengan al menos una calificación mayor o igual a 90 (usando $elemMatch con $gte).

db.students.find({
    courses: { $in: ["Art", "Music"] },
    grades: { $elemMatch: { $gte: 90 } }
}).pretty()

Esta consulta devolverá el documento de "Charlie Brown", quien cumple ambas condiciones.

Resumen

En este laboratorio, has aprendido las técnicas fundamentales para manejar arrays en MongoDB. Comenzaste creando documentos con campos de array y luego practicaste la adición de elementos usando $push y $each. Exploraste la eliminación de elementos por valor con $pull y $pullAll, y por posición con $pop. También aprendiste a actualizar elementos de array específicos usando el operador posicional $ y todos los elementos con el operador $[ ]. Finalmente, practicaste la consulta de documentos basándote en el contenido del array utilizando operadores como $all, $elemMatch, $size y $in. Estas habilidades son cruciales para construir y gestionar aplicaciones con estructuras de datos complejas y anidadas en MongoDB.