MongoDB ou opérateur de pipeline d'agrégation

Dans MongoDB, le $or l'opérateur de pipeline d'agrégation évalue une ou plusieurs expressions et renvoie true le cas échéant évalué à true . Sinon, il renvoie false .

Syntaxe

La syntaxe ressemble à ceci :

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

Exemple

Supposons que nous ayons une collection appelée data avec le document suivant :

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

Voici ce qui se passe lorsque nous utilisons $or pour tester deux conditions par rapport à ce document :

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

Résultat :

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

Nous pouvons voir que $or a renvoyé true , même si l'une des expressions se résout en false . C'est parce qu'il renvoie true le cas échéant des expressions sont true .

Le voici à nouveau, mais avec les deux expressions résolues en false .

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

Résultat :

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

Plus de deux arguments

Comme mentionné, $or accepte une ou plusieurs expressions. L'exemple précédent utilise deux expressions. Voici un exemple qui en utilise trois :

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

Résultat :

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

Dans ce cas, le résultat est true , même si la troisième valeur est évaluée à false .

Un argument

Étant donné que $or accepte une ou plusieurs expressions, il est possible de fournir un seul argument.

Exemple :

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

Résultat :

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

Valeurs nulles, nulles et indéfinies

Le $or l'opérateur évalue 0 , null , et undefined comme false .

Supposons que nous ayons les documents suivants :

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

Voici ce qui se passe lorsque nous appliquons $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" ] } }
         }
   ]
)

Résultat :

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

Ici, j'ai simplement utilisé le champ comme expression.

Voici à quoi cela ressemble lorsque nous appliquons un seul argument aux champs contenant 0 , null , et undefined :

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

Résultat :

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

Tous les champs renvoient false .

Invoquer $or sans arguments

Lorsqu'il est invoqué sans arguments, le $or l'opérateur est évalué à false .

Exemple :

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

Résultat :

{ "result" : false }