MongoDB $ o operador de canalización de agregación

En MongoDB, el $or El operador de canalización de agregación evalúa una o más expresiones y devuelve true si alguno evalúa a true . De lo contrario, devuelve false .

Sintaxis

La sintaxis es así:

{ $or: [ <expression1>, <expression2>, ... ] }

Ejemplo

Supongamos que tenemos una colección llamada data con el siguiente documento:

{ "_id" : 1, "a" : 10, "b" : 2, "c" : 20 }

Esto es lo que sucede cuando usamos $or para probar dos condiciones contra ese documento:

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $or: [ 
              { $gt: [ "$a", 9 ] }, 
              { $lt: [ "$b", 1 ] }
            ] } 
          } 
         }
   ]
)

Resultado:

{ "a" : 10, "b" : 2, "result" : true }

Podemos ver que $or devuelto true , aunque una de las expresiones se resuelve en false . Esto se debe a que devuelve true si cualquiera de las expresiones son true .

Aquí está de nuevo, pero ambas expresiones se resuelven en false .

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $or: [ 
              { $gt: [ "$a", 20 ] }, 
              { $lt: [ "$b", 1 ] }
            ] } 
          } 
         }
   ]
)

Resultado:

{ "a" : 10, "b" : 2, "result" : false }

Más de dos argumentos

Como se mencionó, $or acepta una o más expresiones. El ejemplo anterior utiliza dos expresiones. Aquí hay un ejemplo que usa tres:

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        c: 1,
        result: { $or: [ 
              { $gt: [ "$a", 9 ] }, 
              { $lt: [ "$b", 3 ] }, 
              { $gt: [ "$c", 30 ] } 
            ] } 
          } 
         }
   ]
)

Resultado:

{ "a" : 10, "b" : 2, "c" : 20, "result" : true }

En este caso el resultado es true , aunque el tercer valor se evalúa como false .

Un argumento

Dado que $or acepta una o más expresiones, es posible proporcionar un único argumento.

Ejemplo:

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        result: { $or: [ 
              { $gt: [ "$a", 9 ] }
            ] } 
          } 
         }
   ]
)

Resultado:

{ "a" : 10, "result" : true }

Valores cero, nulos e indefinidos

El $or el operador evalúa 0 , null y undefined como false .

Supongamos que tenemos los siguientes documentos:

{ "_id" : 2, "a" : 0, "b" : 2 }
{ "_id" : 3, "a" : 10, "b" : 0 }
{ "_id" : 4, "a" : 0, "b" : 0 }
{ "_id" : 5, "a" : null, "b" : 2 }
{ "_id" : 6, "a" : 10, "b" : null }
{ "_id" : 7, "a" : null, "b" : null }
{ "_id" : 8, "a" : undefined, "b" : 2 }
{ "_id" : 9, "a" : 10, "b" : undefined }
{ "_id" : 10, "a" : undefined, "b" : undefined }

Esto es lo que sucede cuando aplicamos $or :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $or: [ "$a", "$b" ] } }
         }
   ]
)

Resultado:

{ "a" : 0, "b" : 2, "result" : true }
{ "a" : 10, "b" : 0, "result" : true }
{ "a" : 0, "b" : 0, "result" : false }
{ "a" : null, "b" : 2, "result" : true }
{ "a" : 10, "b" : null, "result" : true }
{ "a" : null, "b" : null, "result" : false }
{ "a" : undefined, "b" : 2, "result" : true }
{ "a" : 10, "b" : undefined, "result" : true }
{ "a" : undefined, "b" : undefined, "result" : false }

Aquí, simplemente usé el campo como expresión.

Así es como se ve cuando aplicamos solo un argumento a los campos que contienen 0 , null y undefined :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 4, 7, 10 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        result: { $or: [ "$a" ] } }
         }
   ]
)

Resultado:

{ "a" : 0, "result" : false }
{ "a" : null, "result" : false }
{ "a" : undefined, "result" : false }

Todos los campos devuelven false .

Invocar $or sin argumentos

Cuando se invoca sin argumentos, $or el operador se evalúa como false .

Ejemplo:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     { $project: { 
        _id: 0,
        result: { $or: [ ] } }
         }
   ]
)

Resultado:

{ "result" : false }