Operatore della pipeline di aggregazione $gte MongoDB

In MongoDB, il $gte l'operatore della pipeline di aggregazione confronta due valori e restituisce true o false , a seconda che il primo valore sia maggiore o uguale al secondo valore.

Esempio

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

{ "_id" : 1, "a" : 250, "b" : 250 }
{ "_id" : 2, "a" : 300, "b" : 250 }
{ "_id" : 3, "a" : 250, "b" : 300 }

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

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $gte: [ "$a", "$b" ] }
          }
     }
   ]
)

Risultato:

{ "a" : 250, "b" : 250, "result" : true }
{ "a" : 300, "b" : 250, "result" : true }
{ "a" : 250, "b" : 300, "result" : false }

Nel primo documento, il a e b i campi sono equivalenti, il che risulta in un valore restituito di true (perché a è effettivamente maggiore o uguale a b ).

Nel secondo documento a è maggiore di b , che restituisce un valore di true (di nuovo perché a è effettivamente maggiore o uguale a b ).

Nel terzo documento, a è inferiore a b e quindi il $gte l'operatore restituisce false (perché a non è maggiore o uguale a b ).

Tipi a confronto

Il $gte 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" : 4, "a" : 250, "b" : "250" }
{ "_id" : 5, "a" : 250, "b" : NumberDecimal("250") }
{ "_id" : 6, "a" : NumberDecimal("250"), "b" : NumberDecimal("250.00") }
{ "_id" : 7, "a" : "2022-01-03T23:30:15.100Z", "b" : ISODate("2021-01-03T23:30:15.100Z") }

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

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

Risultato:

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

Nel documento 4, entrambi a e b hanno un valore di 250 , ma se guardi da vicino b , è una stringa (è racchiusa tra virgolette). In questo caso, $gte restituisce false . Se avessimo usato il $lte operatore invece, questo avrebbe restituito true .

Il documento 5 utilizza anche un valore di 250, ma uno è un doppio e l'altro un decimale. In ogni caso, questi sono equivalenti, e quindi $gte restituisce true .

Allo stesso modo, il documento 6 restituisce true perché entrambi i valori sono equivalenti, anche se uno usa esplicitamente i decimali e l'altro no.

Il documento 7 restituisce true perché, anche se il valore di data/ora in a è maggiore di quello in b , usano tipi diversi per esprimere quella data (a utilizza una stringa di data/ora e b utilizza un oggetto Date). Se avessimo usato il $lte operatore invece, questo avrebbe restituito true a causa dell'ordine di confronto BSON.

Valori Nulli

$gte i confronti possono essere effettuati con null . E confrontando null a null restituisce true .

Supponiamo di aggiungere i seguenti documenti alla nostra raccolta:

{ "_id" : 8, "a" : 250, "b" : null }
{ "_id" : 9, "a" : null, "b" : 250 }
{ "_id" : 10, "a" : null, "b" : null }

Applichiamo $gte a quei documenti:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 8, 9, 10 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $gte: [ "$a", "$b" ] }
          }
     }
   ]
)

Risultato:

{ "a" : 250, "b" : null, "result" : true }
{ "a" : null, "b" : 250, "result" : false }
{ "a" : null, "b" : null, "result" : true }

Campi mancanti

Se uno dei campi che stai cercando di confrontare manca, $gte restituisce true se manca il secondo campo e false se manca il primo.

Supponiamo di aggiungere i seguenti documenti alla nostra raccolta:

{ "_id" : 11, "a" : 250 }
{ "_id" : 12, "b" : 250 }

Applichiamo $gte a quei documenti:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 11, 12 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $gte: [ "$a", "$b" ] }
          }
     }
   ]
)

Risultato:

{ "a" : 250, "result" : true }
{ "b" : 250, "result" : false }

Infinito

Confrontando Infinity a Infinity restituisce true .

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" : 13, "a" : Infinity, "b" : Infinity }
{ "_id" : 14, "a" : -Infinity, "b" : -Infinity }
{ "_id" : 15, "a" : Infinity, "b" : -Infinity }
{ "_id" : 16, "a" : -Infinity, "b" : Infinity }

Applichiamo $gte a quei documenti:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15, 16 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $gte: [ "$a", "$b" ] }
          }
     }
   ]
)

Risultato:

{ "a" : Infinity, "b" : Infinity, "result" : true }
{ "a" : -Infinity, "b" : -Infinity, "result" : true }
{ "a" : Infinity, "b" : -Infinity, "result" : true }
{ "a" : -Infinity, "b" : Infinity, "result" : false }