MongoDB
 sql >> Base de Dados >  >> NoSQL >> MongoDB

MongoDB $ ou Operador de pipeline de agregação


No MongoDB, o $or operador de pipeline de agregação avalia uma ou mais expressões e retorna true se houver, avalie como true . Caso contrário, retorna false .

Sintaxe


A sintaxe fica assim:
{ $or: [ <expression1>, <expression2>, ... ] }

Exemplo


Suponha que tenhamos uma coleção chamada data com o seguinte documento:
{ "_id" : 1, "a" : 10, "b" : 2, "c" : 20 }

Veja o que acontece quando usamos $or para testar duas condições contra esse 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 retornou true , mesmo que uma das expressões resolva para false . Isso ocorre porque ele retorna true se qualquer das expressões são true .

Aqui está novamente, mas com ambas as expressões resolvendo para 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 }

Mais de dois argumentos


Como mencionado, $or aceita uma ou mais expressões. O exemplo anterior usa duas expressões. Aqui está um exemplo que usa três:
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 }

Neste caso o resultado é true , mesmo que o terceiro valor seja avaliado como false .

Um argumento


Dado que $or aceita uma ou mais expressões, é possível fornecer um único argumento.

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

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

Valores zero, nulos e indefinidos


O $or operador avalia 0 , null , e undefined como false .

Suponha que temos os seguintes 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 }

Veja o que acontece quando 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 }

Aqui, eu simplesmente usei o campo como a expressão.

Aqui está o que parece quando aplicamos apenas um argumento aos campos que contêm 0 , null , e 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 os campos retornam false .

Invocar $or sem argumentos


Quando invocado sem argumentos, o $or operador avalia como false .

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

Resultado:
{ "result" : false }