No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Operadores lógicos

24/30
Recursos

¿Qué son los operadores lógicos en MongoDB?

En MongoDB, los operadores lógicos son fundamentales para la construcción de consultas complejas, permitiéndonos filtrar datos y trabajar con múltiples condiciones de búsqueda. Los operadores básicos incluyen AND, OR, NOR y NOT. Cada uno de estos operadores tiene un rol único y ayuda a definir cómo deben combinarse las condiciones en nuestras consultas. Vamos a explorar cómo funcionan y cómo se implementan en MongoDB.

¿Cómo funciona el operador AND en MongoDB?

El operador AND se utiliza para devolver documentos que cumplan con todas las condiciones especificadas. Es como buscar registros que se intersectan entre múltiples conjuntos de criterios:

{
  $and: [
    { "field1": "value1" },
    { "field2": "value2" }
  ]
}

En este bloque de código, utilizamos $and como un array que contiene múltiples condiciones. Es importante destacar que, las consultas en MongoDB usan AND de forma implícita, lo que significa que al establecer múltiples condiciones, MongoDB las ejecuta como un AND por defecto.

¿Cómo implementar el operador OR?

El operador OR se utiliza para obtener documentos que cumplan al menos con una de las condiciones especificadas. A diferencia de AND, OR debe declararse de manera explícita:

{
  $or: [
    { "sector": "Tax Preparers" },
    { "result": "Unable to Locate" }
  ]
}

Aquí, la consulta devolverá documentos que tengan cualquiera de los valores especificados en las condiciones, ya sea el sector "Tax Preparers" o el resultado "Unable to Locate".

¿Qué rol tiene el operador NOR?

El operador NOR es un poco más especial. Se utiliza para excluir documentos que cumplan con cualquiera de las condiciones especificadas, actuando como una combinación de AND y NOT:

{
  $nor: [
    { "sector": "Tax Preparers" },
    { "result": "Unable to Locate" }
  ]
}

Esta consulta devolverá documentos que no pertenezcan al sector "Tax Preparers" y cuyos resultados no sean "Unable to Locate".

¿Cómo se usa el operador NOT?

A diferencia de los demás, el operador NOT es una negación directa y no opera con arrays de condiciones. Modifica una única condición sobre un campo específico:

{
  "result": {
    $not: /Unable to Locate/
  }
}

En este ejemplo, la consulta busca documentos donde el resultado no contenga "Unable to Locate", implementando una negación a través de una expresión regular.

¿Qué más se puede hacer con operadores lógicos?

Los operadores lógicos en MongoDB no se limitan solo al manejo de atributos individuales. Podemos combinarlos para crear consultas más complejas. Por ejemplo, podríamos fusionar AND y OR como se muestra a continuación:

{
  $and: [
    { "airplane": "E-70" },
    {
      $or: [
        { "destinationAirport": "BOG" },
        { "sourceAirport": "BOG" }
      ]
    }
  ]
}

Aquí, buscamos vuelos realizados por el avión "E-70" que han despegado o aterrizado en el aeropuerto de Bogotá. Este tipo de consulta demuestra cómo podemos manejar tanto atributos individuales como múltiples con gran flexibilidad.

Es crucial familiarizarse con estos operadores para manejar datos de manera más efectiva y realizar consultas dinámicas que se adapten a las necesidades específicas de nuestro análisis de datos. Con práctica y experimentación, los operadores lógicos en MongoDB se convierten en herramientas poderosas para manejar grandes volúmenes de información de manera eficiente.

Aportes 9

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Y esta es la forma utilizando el $and implícito y $or explícito.

db.routes.find({ 
    airplane: "E70",
    $or: [
        { dst_airport: "BOG" },
        { src_airport: "BOG" }
    ]
})
  • $and => que cumpla las dos o más condiciones dadas.
  • $or => los que cumplan al menos una condición.
  • $nor => los que no cumplan con ninguna condición.
  • $not => excluye un elemento en especifico y no tiene forma de array
use ("sample_training")

// and de forma implicita
// db.inspections.find({
//     sector: "Tax Preparers - 891",
//     result: "Unable to Locate"
// }).count()

// and de forma exlicita
// $and va dentro de un array [{}, {}, {}]
// db.inspections.find({
//     $and: [
//         {sector: "Tax Preparers - 891"},
//         {result: "Unable to Locate"}        
//     }]
// }).count() 6


// operadores de aca en adelante tienen que ser de forma explicita, no vienen incorporados como and
// or [{}, {}, {}]
// db.inspections.find({
//     $or: [
//         {sector: "Tax Preparers - 891"},
//         {result: "Unable to Locate"}        
//     ]
// }).count() 892

// $nor [{}, {}, {}] para que no incluya ciertos valores
// db.inspections.find({
//     $nor: [
//         {sector: "Tax Preparers - 891"},
//         {result: "Unable to Locate"}        
//     ]
// }).count() 79155 

// db.inspections.find({
//     $nor: [
//         {result: "No Violation Issued"},
//         {result: "Unable to Locate"}        
//     ]
// }   ,{ // projection para que solo traiga los resultados deseados
//     result: 1, 
//     _id: 0
// }
// )

// not no recibe un array directamente como parte de su ejecucion, se aplic hahcia un atributo
// db.inspections.find({
//     result: { $not: {$regex: /Unable to Locate/} }        
// })

Utilizando el $nor con projection explicito, me parece que asi es mejor.

db.inspections.find({
    $nor:[
        {result:"No Violation Issued"},
        {result:"Unable to Locate"}
    ]
}).projection({result:1,_id:0})

Podemos utilizar wildcards para los casos en los que no recordamos exactamente el nombre de esta forma:

use("sample_training")

db.inspections.find({
    sector: /Tax Preparers/i
})
Este Curso esta Super() \n Yo Realmente me lo estoy tomando muy en serio y me gusta mucho MongoDB \n Ya no me equivoco en la sintanxis por queries .find( { \[ $gt : }] } ) en mi MongoSHel ahora me Si funcionan los comandos a la 1ra l. \n Cheeeersss!!!
```js use('sample_mflix'); db.movies.countDocuments(); // si admite filtros, exacto, mas lento use('sample_mflix'); db.movies.estimatedDocumentCount(); // no admite filtros, inexacto, rapido use('sample_mflix'); db.movies.countDocuments({year: 2000}); use('sample_mflix'); db.movies.count({year: 2000}); // obsoleto desde mongo 4.0 ```
```js // Find all teams from Italy or Spain (or) use("football"); db.teams.find({ $or: [{ country: "Italy" }, { country: "Spain" }] }); // Find all teams from England than start with "L" (and) use("football"); db.teams.find({ $and: [ { country: "England" }, { name: /^L/ } // Utilizamos una expresión regular para buscar nombres que comienzan con "L" ] }) // implicitamente se puede omitir el operador $and use("football"); db.teams.find({ country: "England" , name: /^L/ // Utilizamos una expresión regular para buscar nombres que comienzan con "L" }) ```

$and implícito y explícito