Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/tutosrive/db-nosql-2026-1/llms.txt

Use this file to discover all available pages before exploring further.

MongoDB ofrece un rico conjunto de operadores de consulta que permiten filtrar colecciones con precisión quirúrgica. En el contexto de este curso trabajamos principalmente con la colección personas, cuyos documentos contienen campos anidados como name, location, dob y registered. Entender cómo navegar esa estructura y combinar operadores es la base para construir consultas eficientes en cualquier proyecto NoSQL.

​
Operadores de Comparación

Los operadores de comparación permiten evaluar el valor de un campo frente a un umbral o conjunto de valores. Se especifican dentro del documento de filtro que se pasa a find() o a la etapa $match de un pipeline.
OperadorDescripciónEjemplo
$eqIgual a{ edad: { $eq: 25 } }
$neNo igual a{ plan: { $ne: "free" } }
$gtMayor que{ "dob.age": { $gt: 20 } }
$gteMayor o igual{ semestre: { $gte: 5 } }
$ltMenor que{ "dob.age": { $lt: 30 } }
$lteMenor o igual{ "registered.age": { $lte: 10 } }
$inEn un arreglo{ nat: { $in: ["US", "BR"] } }
$ninNo en un arreglo{ gender: { $nin: ["male"] } }
// Personas con edad de nacimiento mayor a 30 años
db.personas.find({ "dob.age": { $gt: 30 } })

// Personas de nacionalidad estadounidense o brasileña
db.personas.find({ nat: { $in: ["US", "BR"] } })

// Personas con tiempo de registro menor o igual a 10 años
db.personas.find({ "registered.age": { $lte: 10 } })

​
Operadores Lógicos

Los operadores lógicos permiten combinar múltiples condiciones de filtro.
OperadorDescripción
$andTodos los criterios deben cumplirse
$orAl menos uno de los criterios debe cumplirse
$notNiega el criterio indicado
$norNinguno de los criterios debe cumplirse
// Personas de género masculino con edad entre 15 y 20 años
db.personas.find({
  $and: [
    { gender: "male" },
    { "dob.age": { $gte: 15 } },
    { "dob.age": { $lte: 20 } }
  ]
})

// Personas masculinas O con edad menor a 18
db.personas.find({
  $or: [
    { gender: "male" },
    { "dob.age": { $lt: 18 } }
  ]
})

// Personas que NO son de nacionalidad US
db.personas.find({
  nat: { $not: { $eq: "US" } }
})
Cuando se aplican múltiples condiciones sobre el mismo campo, MongoDB las evalúa implícitamente con $and. Por ejemplo, { "dob.age": { $gte: 15, $lte: 20 } } es equivalente a usar $and explícitamente con dos condiciones sobre "dob.age".

​
Proyecciones

Las proyecciones controlan qué campos devuelve un documento en el resultado. Se pasan como segundo argumento de find().
  • 1 → incluir el campo.
  • 0 → excluir el campo.
  • _id se incluye por defecto; hay que excluirlo explícitamente con _id: 0.
// Solo nombre, email, edad - sin _id
db.personas.find(
  { "dob.age": { $gt: 20 } },
  { _id: 0, "name.first": 1, email: 1, "dob.age": 1 }
)

// Todos los campos excepto la contraseña y el id
db.personas.find(
  {},
  { _id: 0, login: 0 }
)
No se puede mezclar inclusiones y exclusiones en una misma proyección, salvo para _id. Por ejemplo, { "name.first": 1, email: 0 } produce un error.

​
Notación de Punto

La notación de punto ("campo.subcampo") permite acceder a campos dentro de documentos embebidos. Es imprescindible cuando se trabaja con colecciones que contienen objetos anidados, como personas. Ejemplos de campos anidados en la colección personas:
Ruta con notación de puntoDescripción
"name.first"Primer nombre
"name.last"Apellido
"location.city"Ciudad de residencia
"location.state"Estado o provincia
"location.timezone.description"Descripción de la zona horaria
"dob.age"Edad en años
"dob.date"Fecha de nacimiento (string ISO)
"registered.age"Años desde el registro
// Filtrar por ciudad usando notación de punto
db.personas.find({ "location.city": "Medellín" })

// Proyectar nombre completo y ciudad
db.personas.find(
  {},
  { _id: 0, "name.first": 1, "name.last": 1, "location.city": 1 }
)

​
Ver la Estructura de un Documento

Antes de escribir cualquier consulta, conviene inspeccionar cómo está formado un documento de la colección. El método más rápido es findOne({}): 
// Ver la estructura de la colección
db.personas.findOne({})
Esto devuelve el primer documento disponible con todos sus campos y niveles de anidación, lo que permite conocer los nombres exactos de las rutas antes de construir filtros o proyecciones.

​
Ordenamiento y Límite

MongoDB permite encadenar métodos de cursor para ordenar y paginar los resultados.
MétodoDescripción
.sort({ campo: 1 })Orden ascendente
.sort({ campo: -1 })Orden descendente
.limit(n)Devuelve los primeros n documentos
.skip(n)Salta los primeros n documentos
// Las 10 personas más jóvenes
db.personas.find().sort({ "dob.age": 1 }).limit(10)

// Las 5 personas más viejas, saltando las primeras 10
db.personas.find().sort({ "dob.age": -1 }).skip(10).limit(5)

// Ordenar por apellido ascendentemente y mostrar solo nombre y edad
db.personas.find(
  {},
  { _id: 0, "name.last": 1, "name.first": 1, "dob.age": 1 }
).sort({ "name.last": 1 }).limit(20)
Combina .sort() con .limit() siempre que trabajes con colecciones grandes. Retornar todos los documentos sin límite puede saturar la memoria del cliente.

​
Consultas sobre Arreglos

Cuando un campo de un documento contiene un arreglo, MongoDB permite buscar documentos donde el arreglo contenga uno o varios valores específicos. 
// Documentos donde el arreglo 'aficiones' contiene "bailar"
db.users.find({ aficiones: "bailar" })

// Documentos donde 'aficiones' contiene "catar" O "bailar"
db.users.find({ aficiones: { $in: ["catar", "bailar"] } })
El operador $elemMatch es útil cuando se necesita que un mismo elemento del arreglo cumpla múltiples condiciones: 
// Documentos donde al menos un puntaje sea >= 80 y <= 95
db.resultados.find({
  puntajes: { $elemMatch: { $gte: 80, $lte: 95 } }
})
Sin $elemMatch, MongoDB busca que el arreglo tenga algún elemento que cumpla cada condición por separado, no necesariamente el mismo elemento.

​
Resumen de Métodos de Consulta

find()

Retorna un cursor con todos los documentos que coinciden con el filtro. Acepta un segundo argumento de proyección.

findOne()

Retorna el primer documento que coincide. Ideal para inspeccionar la estructura de una colección.

countDocuments()

Cuenta los documentos que coinciden con el filtro sin retornar los documentos completos.

distinct()

Retorna los valores únicos de un campo en la colección o en el subconjunto filtrado.

Build docs developers (and LLMs) love

Get started for freeTalk to us