Filtrar colecciones de MongoDB

Introducción

En este laboratorio, aprenderá a filtrar eficazmente las colecciones de MongoDB utilizando diversas técnicas de consulta. El laboratorio aborda la aplicación de múltiples condiciones, el uso de operadores de comparación, la coincidencia con expresiones regulares, la comprobación de la existencia de campos y la búsqueda de valores nulos. Estas habilidades son esenciales para consultar y manipular datos en MongoDB, lo que le permite extraer información precisa y relevante de su base de datos. Las instrucciones paso a paso proporcionan ejemplos prácticos y explicaciones para ayudarlo a dominar los fundamentos de la consulta de MongoDB.

Skills Graph

Aplicar múltiples condiciones

En este paso, aprenderá a aplicar múltiples condiciones al consultar colecciones de MongoDB. Las múltiples condiciones le permiten crear consultas más precisas y complejas para filtrar efectivamente sus datos.

Primero, abra una terminal y lance la shell de MongoDB:

mongosh

Ahora, creemos una colección de ejemplo de estudiantes para demostrar consultas con múltiples condiciones:

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" }
])

Exploremos cómo aplicar múltiples condiciones utilizando el operador $and. Esto nos permite especificar múltiples condiciones que deben ser todas verdaderas:

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

Esta consulta devolverá a los estudiantes que tienen 20 años o más Y tienen una calificación de "A". Analicemos las condiciones:

• $gte significa "mayor o igual que"
• $and asegura que ambas condiciones deben cumplirse

Debería ver una salida similar a:

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

También podemos utilizar el operador $or para encontrar documentos que coincidan con al menos una condición:

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

Esta consulta devolverá a los estudiantes que están en Ciencias de la Computación O tienen menos de 21 años.

• $lt significa "menor que"

El resultado incluirá a estudiantes como David (menor de 21 años) y Alice y David (estudiantes de Ciencias de la Computación).

Usar operadores de comparación

En este paso, aprenderá sobre los operadores de comparación de MongoDB que lo ayudan a crear consultas más sofisticadas para filtrar datos basados en diferentes condiciones.

Primero, asegúrese de estar en la shell de MongoDB:

mongosh

Continuemos utilizando la school_database del paso anterior. Si ha cerrado la shell, vuelva a crear la colección de estudiantes:

use school_database

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 }
])

MongoDB proporciona potentes operadores de comparación para ayudarlo a filtrar datos con precisión. Explore algunos de los operadores clave:

1. Mayor que ($gt) y Menor que ($lt):

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

Esta consulta encuentra a los estudiantes mayores de 20 años pero menores de 25 años. En nuestro ejemplo, esto devolvería a Alice.

2. Mayor o igual que ($gte) y Menor o igual que ($lte):

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

Esto encuentra a los estudiantes con 40 a 50 créditos (inclusive). Esto devolverá a Alice y Charlie.

3. No igual a ($ne):

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

Esto devuelve a los estudiantes cuya calificación no es "C", que serían Alice, Bob y Charlie.

Analicemos estos operadores:

• $gt: Mayor que
• $lt: Menor que
• $gte: Mayor o igual que
• $lte: Menor o igual que
• $ne: No igual a

Cada consulta demuestra una forma diferente de filtrar datos con precisión utilizando operadores de comparación.

Coincidir con expresiones regulares

En este paso, aprenderá a usar expresiones regulares (regex) en MongoDB para realizar búsquedas de texto flexibles y potentes en sus colecciones.

Primero, asegúrese de estar en la shell de MongoDB:

mongosh

Continuemos utilizando la school_database y agreguemos más datos diversos:

use school_database

db.students.insertMany([
    { name: "Alice Johnson", age: 22, major: "Computer Science", email: "[email protected]" },
    { name: "Bob Smith", age: 20, major: "Mathematics", email: "[email protected]" },
    { name: "Charlie Brown", age: 25, major: "Physics", email: "[email protected]" },
    { name: "David Lee", age: 19, major: "Computer Engineering", email: "[email protected]" }
])

Las expresiones regulares en MongoDB le permiten realizar búsquedas de texto complejas. Explore diferentes patrones de regex:

1. Encontrar nombres que empiecen con una letra específica:

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

Esta consulta encuentra a los estudiantes cuyo nombre empieza con "A". El símbolo ^ significa "empieza con".

2. Encontrar correos electrónicos de un dominio específico:

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

Esta consulta encuentra a los estudiantes con direcciones de correo electrónico que terminan en "@example.com". El símbolo $ significa "termina con".

3. Búsqueda de regex insensible a mayúsculas y minúsculas:

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

Esto encuentra nombres que contengan "johnson" sin importar si están en mayúsculas o minúsculas. El $options: "i" hace que la búsqueda sea insensible a mayúsculas y minúsculas.

4. Coincidencias parciales:

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

Esto encuentra a los estudiantes con "Computer" en cualquier parte de su especialización.

Los patrones de regex proporcionan maneras potentes de buscar y filtrar datos:

• ^: Empieza con
• $: Termina con
• $options: "i": Coincidencia insensible a mayúsculas y minúsculas
• Las coincidencias parciales no requieren símbolos especiales

Comprobar la existencia de campos

En este paso, aprenderá a comprobar la existencia de campos en los documentos de MongoDB utilizando operadores poderosos que lo ayudan a filtrar colecciones basadas en la presencia de campos.

Primero, asegúrese de estar en la shell de MongoDB:

mongosh

Cree una colección con documentos de diferentes estructuras para demostrar las comprobaciones de existencia de campos:

use school_database

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

MongoDB proporciona el operador $exists para comprobar la presencia de campos:

1. Encuentre documentos con un campo específico:

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

Esta consulta devuelve a los estudiantes que tienen un campo de beca. En nuestro ejemplo, esto devolverá el documento de Alice.

2. Encuentre documentos sin un campo específico:

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

Esta consulta devuelve a los estudiantes sin un campo de pasantía, lo que incluye a Alice, Bob y David.

3. Combine $exists con comprobaciones de campos anidados:

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

Esto encuentra documentos con un campo de contacto que también tiene un subcampo de teléfono, lo que coincide con el documento de David.

Puntos claves sobre la existencia de campos:

• $exists: true comprueba si un campo está presente
• $exists: false comprueba si un campo está ausente
• Puede crear consultas complejas comprobando la existencia de campos anidados

Encontrar valores nulos

En este paso, aprenderá a encontrar y trabajar con valores nulos en MongoDB, comprendiendo la diferencia entre nulo, indefinido y campos faltantes.

Primero, asegúrese de estar en la shell de MongoDB:

mongosh

Cree una colección con documentos que contengan valores nulos e indefinidos:

use school_database

db.students.insertMany([
    { name: "Alice Johnson", age: 22, email: null },
    { name: "Bob Smith", age: null, major: "Mathematics" },
    { name: "Charlie Brown", age: 25, phone: undefined },
    { name: "David Lee", contact: { email: null } }
])

MongoDB proporciona maneras específicas de consultar valores nulos e indefinidos:

1. Encuentre documentos con valores nulos:

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

Esta consulta devuelve documentos donde el campo de correo electrónico está explícitamente establecido en nulo. En nuestro ejemplo, esto devolverá el documento de Alice.

2. Encuentre documentos con campos nulos:

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

Esto encuentra documentos donde el campo de edad es específicamente nulo. Esto devolverá el documento de Bob.

3. Compruebe la existencia de nulo en documentos anidados:

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

Esto encuentra documentos con correo electrónico nulo en un objeto de contacto anidado, lo que coincide con el documento de David.

4. Distinga entre valores nulos y campos faltantes:

db.students.find({
  $and: [{ phone: null }, { phone: { $exists: true } }]
});

Esta consulta encuentra documentos donde el campo de teléfono existe y es nulo. En nuestro ejemplo, no devolverá ningún documento.

Puntos claves sobre valores nulos:

• null representa una ausencia intencional de cualquier valor de objeto
• Diferente de undefined, que significa que una variable no ha sido asignada
• Utilice $exists para comprobar la presencia de campos
• Tenga cuidado con las consultas de documentos anidados

Resumen

En este laboratorio, aprendió cómo aplicar múltiples condiciones al consultar colecciones de MongoDB utilizando los operadores $and y $or. Esto le permite crear consultas más precisas y complejas para filtrar sus datos de manera efectiva. También exploró varios operadores de comparación, como $gte (mayor o igual que) y $lt (menor que), para afinar sus criterios de búsqueda. Además, descubrió cómo coincidir con expresiones regulares, comprobar la existencia de campos y encontrar valores nulos en sus colecciones de MongoDB, lo que le proporciona herramientas poderosas para filtrar y recuperar efectivamente los datos que necesita.