MongoDB $ o operatore della pipeline di aggregazione

In MongoDB, il $or l'operatore della pipeline di aggregazione valuta una o più espressioni e restituisce true se presente, restituisce true . Altrimenti restituisce false .

Sintassi

La sintassi è questa:

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

Esempio

Supponiamo di avere una raccolta chiamata data con il seguente documento:

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

Ecco cosa succede quando utilizziamo $or per verificare due condizioni rispetto a quel documento:

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

Risultato:

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

Possiamo vedere che $or restituito true , anche se una delle espressioni si risolve in false . Questo perché restituisce true se qualsiasi delle espressioni sono true .

Eccolo di nuovo, ma con entrambe le espressioni che si risolvono in false .

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

Risultato:

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

Più di due argomenti

Come accennato, $or accetta una o più espressioni. L'esempio precedente utilizza due espressioni. Ecco un esempio che ne utilizza tre:

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

Risultato:

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

In questo caso il risultato è true , anche se il terzo valore restituisce false .

Un argomento

Dato che $or accetta una o più espressioni, è possibile fornire un solo argomento.

Esempio:

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

Risultato:

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

Valori zero, nulli e non definiti

Il $or l'operatore valuta 0 , null e undefined come false .

Supponiamo di avere i seguenti documenti:

{ "_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 }

Ecco cosa succede quando applichiamo $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" ] } }
         }
   ]
)

Risultato:

{ "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 }

Qui, ho semplicemente usato il campo come espressione.

Ecco come appare quando applichiamo un solo argomento ai campi che contengono 0 , null e undefined :

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

Risultato:

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

Tutti i campi restituiscono false .

Richiama $or senza argomenti

Quando viene invocato senza argomenti, $or l'operatore restituisce false .

Esempio:

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

Risultato:

{ "result" : false }