Filtrar Colecciones de MongoDB

Introducción

En este laboratorio, aprenderá a filtrar colecciones de MongoDB de manera efectiva utilizando diversas técnicas de consulta. El laboratorio cubre la aplicación de múltiples condiciones, el uso de operadores de comparación, la coincidencia con expresiones regulares, la verificación de la existencia de campos y la búsqueda de valores nulos. Estas habilidades son esenciales para la recuperación precisa de datos en MongoDB. Las instrucciones paso a paso proporcionan ejemplos prácticos para ayudarle a dominar los fundamentos de las consultas en MongoDB.

Aplicar Múltiples Condiciones

En este paso, aprenderá a aplicar múltiples condiciones para filtrar documentos en una colección de MongoDB. Esto permite consultas más precisas al combinar varios criterios.

Primero, abra su terminal e inicie el Shell de MongoDB (mongosh). Este shell interactivo es donde ejecutará todos sus comandos de base de datos.

mongosh

Una vez dentro del shell mongosh, verá un prompt >. Cambiemos a una nueva base de datos llamada school_database y creemos una colección students con algunos datos de ejemplo.

use school_database

db.students.insertMany([
  { name: "Alice", age: 22, grade: "A", major: "Computer Science" },
  { name: "Bob", age: 20, grade: "B", major: "Mathematics" },
  { name: "Charlie", age: 25, grade: "A", major: "Physics" },
  { name: "David", age: 19, grade: "C", major: "Computer Science" }
]);

Este comando inserta cuatro documentos en la colección students. Ahora, busquemos estudiantes que cumplan múltiples condiciones. Usaremos el operador $and para encontrar estudiantes que tengan 20 años o más Y una calificación de "A".

db.students.find({
  $and: [{ age: { $gte: 20 } }, { grade: "A" }]
});

Esta consulta utiliza $gte, que significa "mayor o igual que" (greater than or equal to), y $and para asegurar que ambas condiciones se cumplan. La salida mostrará a Alice y Charlie:

[
  {
    _id: ObjectId("..."),
    name: 'Alice',
    age: 22,
    grade: 'A',
    major: 'Computer Science'
  },
  {
    _id: ObjectId("..."),
    name: 'Charlie',
    age: 25,
    grade: 'A',
    major: 'Physics'
  }
]

A continuación, usaremos el operador $or para encontrar documentos que coincidan con al menos una de varias condiciones. Esta consulta busca estudiantes que estén cursando "Computer Science" O que tengan menos de 21 años.

db.students.find({
  $or: [{ major: "Computer Science" }, { age: { $lt: 21 } }]
});

Esta consulta utiliza $lt, que significa "menor que" (less than). El resultado incluirá a Alice y David (estudiantes de Computer Science) y a Bob y David (menores de 21 años). Dado que David cumple ambas condiciones, aparece una sola vez.

[
  {
    _id: ObjectId("..."),
    name: 'Alice',
    age: 22,
    grade: 'A',
    major: 'Computer Science'
  },
  {
    _id: ObjectId("..."),
    name: 'Bob',
    age: 20,
    grade: 'B',
    major: 'Mathematics'
  },
  {
    _id: ObjectId("..."),
    name: 'David',
    age: 19,
    grade: 'C',
    major: 'Computer Science'
  }
]

En el siguiente paso, explorará más operadores de comparación. Por ahora, puede permanecer en el shell mongosh.

Usar Operadores de Comparación

En este paso, utilizará los operadores de comparación de MongoDB para construir consultas más sofisticadas. Estos operadores le permiten filtrar datos basándose en comparaciones de valores.

Debería seguir en el shell mongosh del paso anterior. Primero, vamos a limpiar la colección existente e insertar nuevos datos con un campo credits para trabajar.

db.students.drop();

db.students.insertMany([
  {
    name: "Alice",
    age: 22,
    grade: "A",
    major: "Computer Science",
    credits: 45
  },
  { name: "Bob", age: 20, grade: "B", major: "Mathematics", credits: 35 },
  { name: "Charlie", age: 25, grade: "A", major: "Physics", credits: 50 },
  { name: "David", age: 19, grade: "C", major: "Computer Science", credits: 25 }
]);

Ahora, usemos los operadores "mayor que" ($gt) y "menor que" ($lt) para encontrar estudiantes que sean mayores de 20 años pero menores de 25.

db.students.find({ age: { $gt: 20, $lt: 25 } });

Esta consulta devolverá solo el documento de Alice, que tiene 22 años.

A continuación, use "mayor o igual que" ($gte) y "menor o igual que" ($lte) para encontrar estudiantes con créditos entre 40 y 50, ambos inclusive.

db.students.find({ credits: { $gte: 40, $lte: 50 } });

Esta consulta devolverá a Alice (45 créditos) y a Charlie (50 créditos).

Finalmente, usemos el operador "no igual a" ($ne) para encontrar todos los estudiantes cuya calificación no sea "C".

db.students.find({ grade: { $ne: "C" } });

Esto devolverá a Alice, Bob y Charlie, excluyendo a David, que tiene la calificación "C". Estos operadores son fundamentales para crear consultas detalladas y específicas en MongoDB.

Coincidir con Expresiones Regulares

Las expresiones regulares (regex) proporcionan una forma flexible de realizar búsquedas de texto potentes. En este paso, aprenderá a usar regex en sus consultas de MongoDB.

Primero, preparemos los datos para este paso. Limpie la colección e inserte nuevos documentos con campos de cadena de texto más detallados.

db.students.drop();

db.students.insertMany([
  {
    name: "Alice Johnson",
    age: 22,
    major: "Computer Science",
    email: "alice.j@example.com"
  },
  {
    name: "Bob Smith",
    age: 20,
    major: "Mathematics",
    email: "bob.smith@university.edu"
  },
  {
    name: "Charlie Brown",
    age: 25,
    major: "Physics",
    email: "charlie.brown@school.org"
  },
  {
    name: "David Lee",
    age: 19,
    major: "Computer Engineering",
    email: "david.lee@tech.net"
  }
]);

Para encontrar todos los estudiantes cuyos nombres comiencen con "Alice", puede usar el operador $regex con el ancla ^.

db.students.find({ name: { $regex: "^Alice" } });

Esta consulta devolverá el documento de "Alice Johnson". El carácter ^ indica el inicio de la cadena.

Para encontrar estudiantes con una dirección de correo electrónico de un dominio específico, como example.com, use el ancla $ para coincidir con el final de la cadena.

db.students.find({ email: { $regex: "@example.com$" } });

Esto encontrará a "Alice Johnson", cuyo correo electrónico termina en @example.com.

También puede realizar búsquedas que no distingan entre mayúsculas y minúsculas. La siguiente consulta busca cualquier estudiante con "smith" en su nombre, independientemente de las mayúsculas/minúsculas, utilizando la opción i.

db.students.find({ name: { $regex: "smith", $options: "i" } });

Esta consulta coincidirá con "Bob Smith".

Finalmente, para encontrar cualquier especialidad que contenga la palabra "Computer", puede usar un patrón de regex simple sin anclas.

db.students.find({ major: { $regex: "Computer" } });

Esto devolverá tanto a "Alice Johnson" (Computer Science) como a "David Lee" (Computer Engineering).

Comprobar la Existencia de Campos

A veces, los documentos de una colección tienen estructuras diferentes. Este paso le enseña cómo consultar documentos basándose en si un campo específico existe o no.

Comencemos insertando un nuevo conjunto de documentos donde faltan algunos campos.

db.students.drop();

db.students.insertMany([
  { name: "Alice", age: 22, major: "Computer Science", scholarship: 1000 },
  { name: "Bob", age: 20, major: "Mathematics" },
  { name: "Charlie", age: 25, major: "Physics", internship: "Research Lab" },
  { name: "David", age: 19, contact: { phone: "555-1234" } }
]);

Para encontrar todos los estudiantes que tienen un campo scholarship, use el operador $exists con el valor true.

db.students.find({ scholarship: { $exists: true } });

Esta consulta devolverá solo el documento de Alice, ya que es la única con el campo scholarship.

Por el contrario, para encontrar estudiantes que no tienen un campo internship, establezca $exists en false.

db.students.find({ internship: { $exists: false } });

Esto devolverá los documentos de Alice, Bob y David, ya que ninguno de ellos tiene el campo internship.

El operador $exists también funciona en campos anidados. Para encontrar un estudiante que tenga un objeto contact que contenga un campo phone, puede usar la notación de puntos.

db.students.find({ "contact.phone": { $exists: true } });

Esta consulta busca específicamente el campo phone dentro del objeto contact y devolverá el documento de David.

Encontrar Valores Null

En este último paso, aprenderá a consultar documentos que contienen valores null. Un valor null representa la ausencia intencional de un valor.

Primero, configuremos una colección con documentos que contengan valores null y campos faltantes.

db.students.drop();

db.students.insertMany([
  { name: "Alice", age: 22, email: null },
  { name: "Bob", age: 20, major: "Mathematics" },
  { name: "Charlie", age: null, major: "Physics" },
  { name: "David", contact: { email: null } }
]);

Para encontrar documentos donde un campo tiene un valor null, puede consultar null directamente. La siguiente consulta encuentra todos los documentos donde el campo email es null O el campo email no existe.

db.students.find({ email: null });

Esta consulta devolverá los cuatro documentos: Alice (donde email es explícitamente null), Bob (donde el campo email falta), Charlie (donde el campo email falta) y David (donde el campo email falta).

Para encontrar solo los documentos donde un campo está explícitamente establecido en null, debe combinar la verificación de null con una verificación $exists.

db.students.find({ email: { $type: "null" } });

Alternativamente, puede usar el operador $type. El tipo BSON para null es 10. Esta consulta solo devolverá el documento de Alice.

db.students.find({ email: { $type: 10 } });

También puede consultar valores null dentro de documentos anidados. La siguiente consulta encuentra documentos donde el campo email dentro del objeto contact es null O donde el campo contact no existe.

db.students.find({ "contact.email": null });

Esto devolverá los cuatro documentos: Alice, Bob y Charlie (donde falta el campo contact), y David (donde contact.email es explícitamente null). Comprender cómo consultar valores null es crucial para manejar datos incompletos o dispersos.

Cuando haya terminado, puede salir del shell mongosh escribiendo exit o presionando Ctrl+D.

Resumen

En este laboratorio, ha aprendido varias técnicas esenciales para filtrar colecciones en MongoDB. Ha practicado la aplicación de múltiples condiciones utilizando los operadores $and y $or, lo que permite la creación de consultas complejas y precisas. También ha explorado una variedad de operadores de comparación como $gt, $lt y $ne para refinar los criterios de búsqueda. Además, ha adquirido experiencia en la coincidencia de texto utilizando expresiones regulares, la verificación de la existencia de campos con $exists y la consulta de valores null. Estas habilidades proporcionan una base sólida para la recuperación y manipulación de datos eficaz en MongoDB.