MongoDB $eller Aggregation Pipeline Operator

I MongoDB, $or aggregeringspipeline-operatorn utvärderar ett eller flera uttryck och returnerar true om någon utvärderas till true . Annars returnerar den false .

Syntax

Syntaxen ser ut så här:

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

Exempel

Anta att vi har en samling som heter data med följande dokument:

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

Det här är vad som händer när vi använder $or att testa för två villkor mot det dokumentet:

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

Resultat:

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

Vi kan se att $or returnerade true , även om ett av uttrycken löser sig till false . Detta beror på att den returnerar true om några av uttrycken är true .

Här är den igen, men med båda uttrycken löser sig till false .

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

Resultat:

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

Fler än två argument

Som nämnts, $or accepterar ett eller flera uttryck. Det föregående exemplet använder två uttryck. Här är ett exempel som använder 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 ] } 
            ] } 
          } 
         }
   ]
)

Resultat:

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

I det här fallet är resultatet true , även om det tredje värdet utvärderas till false .

Ett argument

Med tanke på att $or accepterar ett eller flera uttryck, är det möjligt att tillhandahålla ett enda argument.

Exempel:

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

Resultat:

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

Noll-, noll- och odefinierade värden

$or operatören utvärderar 0 , null och undefined som false .

Anta att vi har följande dokument:

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

Det här är vad som händer när vi använder $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" ] } }
         }
   ]
)

Resultat:

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

Här använde jag helt enkelt fältet som uttryck.

Så här ser det ut när vi tillämpar bara ett argument på fälten som innehåller 0 , null och undefined :

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

Resultat:

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

Alla fält returnerar false .

Anropa $or utan argument

När den anropas utan argument, visas $or operatorn utvärderar till false .

Exempel:

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

Resultat:

{ "result" : false }