MongoDB $ nebo Aggregation Pipeline Operator

V MongoDB, $or operátor agregačního kanálu vyhodnotí jeden nebo více výrazů a vrátí true pokud nějaké vyhodnotí jako true . Jinak vrátí false .

Syntaxe

Syntaxe vypadá takto:

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

Příklad

Předpokládejme, že máme kolekci nazvanou data s následujícím dokumentem:

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

Zde je to, co se stane, když použijeme $or pro testování dvou podmínek proti tomuto dokumentu:

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

Výsledek:

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

Vidíme, že $or vrátil true , i když se jeden z výrazů vyhodnotí jako false . Je to proto, že vrací true pokud nějaké výrazů je true .

Tady je to znovu, ale oba výrazy se vyřeší na false .

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

Výsledek:

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

Více než dva argumenty

Jak již bylo zmíněno, $or přijímá jeden nebo více výrazů. Předchozí příklad používá dva výrazy. Zde je příklad, který používá tři:

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

Výsledek:

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

V tomto případě je výsledek true , i když je třetí hodnota vyhodnocena jako false .

Jeden argument

Vzhledem k tomu, že $or přijímá jeden nebo více výrazů, je možné poskytnout jeden argument.

Příklad:

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

Výsledek:

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

Nulové, nulové a nedefinované hodnoty

$or operátor vyhodnotí 0 , null a undefined jako false .

Předpokládejme, že máme následující 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 }

Zde je to, co se stane, když použijeme $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" ] } }
         }
   ]
)

Výsledek:

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

Zde jsem jednoduše použil pole jako výraz.

Takto to vypadá, když na pole obsahující 0 použijeme pouze jeden argument , null a undefined :

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

Výsledek:

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

Všechna pole vrátí false .

Vyvolejte $or bez argumentů

Při vyvolání bez argumentů $or operátor vyhodnotí jako false .

Příklad:

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

Výsledek:

{ "result" : false }