Operatore della pipeline di aggregazione $eq MongoDB

In MongoDB, il $eq l'operatore della pipeline di aggregazione confronta due valori e restituisce true o false , a seconda che i due valori siano equivalenti o meno.

Esempio

Supponiamo di avere una raccolta chiamata data con i seguenti documenti:

{ "_id" : 1, "a" : 250, "b" : 250 }
{ "_id" : 2, "a" : 250, "b" : 100 }

Possiamo usare il $eq operatore per confrontare il a e b campi:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2 ] } } },
     {
       $project:
          {
            a: 1,
            b: 1,
            isEquivalent: { $eq: [ "$a", "$b" ] }
          }
     }
   ]
)

Risultato:

{ "_id" : 1, "a" : 250, "b" : 250, "isEquivalent" : true }
{ "_id" : 2, "a" : 250, "b" : 100, "isEquivalent" : false }

Nel primo documento, il a e b i campi sono equivalenti, il che risulta in un valore restituito di true . Ma nel secondo documento non sono equivalenti, il che si traduce in un valore restituito di false .

Tipi a confronto

Il $eq l'operatore confronta sia il valore che il tipo utilizzando l'ordine di confronto BSON specificato per valori di tipi diversi.

Supponiamo che la nostra collezione contenga i seguenti documenti:

{ "_id" : 3, "a" : 250, "b" : "250" }
{ "_id" : 4, "a" : 250, "b" : NumberDecimal("250") }
{ "_id" : 5, "a" : NumberDecimal("250"), "b" : NumberDecimal("250.00") }
{ "_id" : 6, "a" : "2021-01-03T23:30:15.100Z", "b" : ISODate("2021-01-03T23:30:15.100Z") }

Possiamo applicare $eq al a e b campi di tali documenti:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 3, 4, 5, 6 ] } } },
     {
       $project:
          {
            a: 1,
            b: 1,
            isEquivalent: { $eq: [ "$a", "$b" ] }
          }
     }
   ]
).pretty()

Risultato:

{ "_id" : 3, "a" : 250, "b" : "250", "isEquivalent" : false }
{ "_id" : 4, "a" : 250, "b" : NumberDecimal("250"), "isEquivalent" : true }
{
	"_id" : 5,
	"a" : NumberDecimal("250"),
	"b" : NumberDecimal("250.00"),
	"isEquivalent" : true
}
{
	"_id" : 6,
	"a" : "2021-01-03T23:30:15.100Z",
	"b" : ISODate("2021-01-03T23:30:15.100Z"),
	"isEquivalent" : false
}

Nel documento 3, entrambi a e b hanno un valore di 250 , ma se guardi da vicino b , è una stringa (è racchiusa tra virgolette). Pertanto, il primo documento restituisce false .

Il documento 4 restituisce true perché entrambi i campi contengono 250 ed entrambi sono numeri. Questo è vero anche se a è un doppio e b è un decimale.

Il documento 5 restituisce true perché entrambi sono decimali ed entrambi hanno lo stesso valore (anche se uno usa esplicitamente i decimali e l'altro no).

Il documento 6 restituisce false perché, anche se il valore di data/ora è esattamente lo stesso, usano tipi diversi per esprimere quella data (a utilizza una stringa di data/ora e b utilizza un oggetto Date).

Valori Nulli

Confrontando un valore con null restituisce false , a meno che non siano entrambi null .

Supponiamo di aggiungere i seguenti documenti alla nostra raccolta:

{ "_id" : 7, "a" : 250, "b" : null }
{ "_id" : 8, "a" : null, "b" : null }

Applichiamo $eq a quei documenti:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 7, 8 ] } } },
     {
       $project:
          {
            a: 1,
            b: 1,
            isEquivalent: { $eq: [ "$a", "$b" ] }
          }
     }
   ]
)

Risultato:

{ "_id" : 7, "a" : 250, "b" : null, "isEquivalent" : false }
{ "_id" : 8, "a" : null, "b" : null, "isEquivalent" : true }

Campi mancanti

Se uno dei campi che stai cercando di confrontare manca, $eq restituisce false .

Supponiamo di aggiungere il seguente documento alla nostra raccolta:

{ "_id" : 9, "a" : 250 }

Applichiamo $eq a quel documento:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 9 ] } } },
     {
       $project:
          {
            a: 1,
            b: 1,
            isEquivalent: { $eq: [ "$a", "$b" ] }
          }
     }
   ]
)

Risultato:

{ "_id" : 9, "a" : 250, "isEquivalent" : false }

Infinito

Confrontando Infinity a Infinity restituisce true .

Confrontando -Infinity a -Infinity restituisce true .

Confrontando Infinity a -Infinity restituisce false .

Supponiamo di aggiungere i seguenti documenti alla nostra raccolta:

{ "_id" : 10, "a" : Infinity, "b" : Infinity }
{ "_id" : 11, "a" : -Infinity, "b" : -Infinity }
{ "_id" : 12, "a" : Infinity, "b" : -Infinity }

Applichiamo $eq a quei documenti:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11, 12 ] } } },
     {
       $project:
          {
            a: 1,
            b: 1,
            isEquivalent: { $eq: [ "$a", "$b" ] }
          }
     }
   ]
)

Risultato:

{ "_id" : 10, "a" : Infinity, "b" : Infinity, "isEquivalent" : true }
{ "_id" : 11, "a" : -Infinity, "b" : -Infinity, "isEquivalent" : true }
{ "_id" : 12, "a" : Infinity, "b" : -Infinity, "isEquivalent" : false }