Operatore della pipeline di aggregazione $gt MongoDB

In MongoDB, il $gt l'operatore della pipeline di aggregazione confronta due valori e restituisce true o false , a seconda che il primo valore sia maggiore o meno del 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 $gt operatore per confrontare il a e b campi:

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

Risultato:

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

Nel primo documento, il a e b i campi sono equivalenti, il che si traduce in un valore restituito di false (perché a non è maggiore di b ).

Ma nel secondo documento a è maggiore di b , che restituisce un valore di true .

Nel terzo documento, a è inferiore a b e quindi il $gt l'operatore restituisce false .

Tipi a confronto

Il $gt 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 $gt al a e b campi di tali documenti:

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

Risultato:

{ "_id" : 4, "a" : 250, "b" : "250", "isGreaterThan" : false }
{
	"_id" : 5,
	"a" : 250,
	"b" : NumberDecimal("250"),
	"isGreaterThan" : false
}
{
	"_id" : 6,
	"a" : NumberDecimal("250"),
	"b" : NumberDecimal("250.00"),
	"isGreaterThan" : false
}
{
	"_id" : 7,
	"a" : "2022-01-03T23:30:15.100Z",
	"b" : ISODate("2021-01-03T23:30:15.100Z"),
	"isGreaterThan" : 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, $gt restituisce false . Se avessimo usato il $lt 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 $gt restituisce false .

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

Il documento 7 restituisce false 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 $lt operatore invece, questo avrebbe restituito true a causa dell'ordine di confronto BSON.

Valori Nulli

$gt 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" : null }

Applichiamo $gt a quei documenti:

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

Risultato:

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

Campi mancanti

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

Supponiamo di aggiungere i seguenti documenti alla nostra raccolta:

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

Applichiamo $gt a quei documenti:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            isGreaterThan: { $gt: [ "$a", "$b" ] }
          }
     }
   ]
)

Risultato:

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

Infinito

Confrontando Infinity a Infinity restituisce false .

Confrontando -Infinity a -Infinity restituisce false .

Confrontando Infinity a -Infinity restituisce true .

Confrontando -Infinity a Infinity restituisce false .

Supponiamo di aggiungere i seguenti documenti alla nostra raccolta:

{ "_id" : 12, "a" : Infinity, "b" : Infinity }
{ "_id" : 13, "a" : -Infinity, "b" : -Infinity }
{ "_id" : 14, "a" : Infinity, "b" : -Infinity }
{ "_id" : 15, "a" : -Infinity, "b" : Infinity }

Applichiamo $gt a quei documenti:

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

Risultato:

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