MongoDB $lub operator potoku agregacji

W MongoDB $or Operator potoku agregacji ocenia jedno lub więcej wyrażeń i zwraca true jeśli jakakolwiek ocena ma wartość true . W przeciwnym razie zwraca false .

Składnia

Składnia wygląda tak:

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

Przykład

Załóżmy, że mamy kolekcję o nazwie data z następującym dokumentem:

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

Oto, co się dzieje, gdy używamy $or aby przetestować pod kątem dwóch warunków w odniesieniu do tego dokumentu:

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

Wynik:

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

Widzimy, że $or zwrócono true , nawet jeśli jedno z wyrażeń ma postać false . Dzieje się tak, ponieważ zwraca true jeśli jakikolwiek z wyrażeń jest true .

Oto znowu, ale z obydwoma wyrażeniami rozwiązywanymi na false .

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

Wynik:

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

Więcej niż dwa argumenty

Jak wspomniano, $or akceptuje jedno lub więcej wyrażeń. W poprzednim przykładzie zastosowano dwa wyrażenia. Oto przykład, który wykorzystuje trzy:

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

Wynik:

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

W tym przypadku wynikiem jest true , mimo że trzecia wartość ma wartość false .

Jeden argument

Biorąc pod uwagę, że $or akceptuje jedno lub więcej wyrażeń, możliwe jest podanie pojedynczego argumentu.

Przykład:

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

Wynik:

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

Wartości zero, zero i niezdefiniowane

$or operator ocenia 0 , null i undefined jako false .

Załóżmy, że mamy następujące dokumenty:

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

Oto, co się dzieje, gdy zastosujemy $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" ] } }
         }
   ]
)

Wynik:

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

Tutaj po prostu użyłem pola jako wyrażenia.

Oto jak to wygląda, gdy zastosujemy tylko jeden argument do pól zawierających 0 , null i undefined :

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

Wynik:

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

Wszystkie pola zwracają false .

Wywołaj $or bez argumentów

Po wywołaniu bez argumentów $or operator ocenia jako false .

Przykład:

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

Wynik:

{ "result" : false }