MongoDB $gte Aggregation Pipeline Operator

In MongoDB, de $gte aggregatiepijplijnoperator vergelijkt twee waarden en retourneert ofwel true of false , afhankelijk van of de eerste waarde groter is dan of gelijk is aan de tweede waarde.

Voorbeeld

Stel dat we een verzameling hebben met de naam data met de volgende documenten:

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

We kunnen de $gte . gebruiken operator om de a . te vergelijken en b velden:

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

Resultaat:

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

In het eerste document, de a en b velden zijn equivalent, wat resulteert in een retourwaarde van true (omdat a is inderdaad groter dan of gelijk aan b ).

In het tweede document a is groter dan b , wat resulteert in een retourwaarde van true (opnieuw omdat a is inderdaad groter dan of gelijk aan b ).

In het derde document, a is kleiner dan b en daarom de $gte operator retourneert false (omdat a is niet groter dan of gelijk aan b ).

Typen vergelijken

De $gte operator vergelijkt zowel waarde als type met behulp van de gespecificeerde BSON-vergelijkingsvolgorde voor waarden van verschillende typen.

Stel dat onze collectie de volgende documenten bevat:

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

We kunnen $gte . toepassen naar de a en b velden van die documenten:

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

Resultaat:

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

In document 4, zowel a en b een waarde hebben van 250 , maar als je goed kijkt naar b , het is een string (het is omgeven door dubbele aanhalingstekens). In dit geval $gte retourneert false . Als we de $lte . hadden gebruikt operator zou dit true hebben opgeleverd .

Document 5 gebruikt ook een waarde van 250, maar de ene is een dubbele en de andere een decimaal. Hoe dan ook, deze zijn equivalent, en dus $gte retourneert true .

Op dezelfde manier retourneert document 6 true omdat beide waarden equivalent zijn, ook al gebruikt de ene expliciet decimalen en de andere niet.

Document 7 retourneert true omdat, hoewel de datum/tijd-waarde in a is groter dan die in b , gebruiken ze verschillende typen om die datum uit te drukken (a gebruikt een datum/tijd-tekenreeks en b gebruikt een Date-object). Als we de $lte . hadden gebruikt operator zou dit true hebben opgeleverd vanwege de BSON-vergelijkingsvolgorde.

Null-waarden

$gte vergelijkingen kunnen worden gemaakt met null . En het vergelijken van null naar null retourneert true .

Stel dat we de volgende documenten aan onze collectie toevoegen:

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

Laten we $gte toepassen naar die documenten:

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

Resultaat:

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

Ontbrekende velden

Als een van de velden die u probeert te vergelijken ontbreekt, $gte retourneert true als het tweede veld ontbreekt, en false als de eerste ontbreekt.

Stel dat we de volgende documenten aan onze collectie toevoegen:

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

Laten we $gte toepassen naar die documenten:

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

Resultaat:

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

Oneindig

Infinity vergelijken tot Infinity retourneert true .

-Infinity vergelijken naar -Infinity retourneert true .

Infinity vergelijken naar -Infinity retourneert true .

-Infinity vergelijken tot Infinity retourneert false .

Stel dat we de volgende documenten aan onze collectie toevoegen:

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

Laten we $gte toepassen naar die documenten:

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

Resultaat:

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