Nhà điều hành đường ống tổng hợp MongoDB $ gte

Trong MongoDB, $gte toán tử đường ống tổng hợp so sánh hai giá trị và trả về true hoặc false , tùy thuộc vào việc giá trị đầu tiên có lớn hơn hoặc bằng giá trị thứ hai hay không.

Ví dụ

Giả sử chúng ta có một tập hợp được gọi là data với các tài liệu sau:

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

Chúng ta có thể sử dụng $gte toán tử để so sánh a và b lĩnh vực:

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

Kết quả:

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

Trong tài liệu đầu tiên, a và b các trường tương đương nhau, dẫn đến giá trị trả về là true (bởi vì a thực sự lớn hơn hoặc bằng b ).

Trong tài liệu thứ hai a lớn hơn b , dẫn đến giá trị trả về là true (một lần nữa vì a thực sự lớn hơn hoặc bằng b ).

Trong tài liệu thứ ba, a nhỏ hơn b và do đó $gte toán tử trả về false (bởi vì a không lớn hơn hoặc bằng b ).

So sánh các loại

$gte toán tử so sánh cả giá trị và kiểu bằng cách sử dụng thứ tự so sánh BSON được chỉ định cho các giá trị của các kiểu khác nhau.

Giả sử bộ sưu tập của chúng tôi chứa các tài liệu sau:

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

Chúng tôi có thể áp dụng $gte tới a và b các trường của các tài liệu đó:

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

Kết quả:

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

Trong tài liệu 4, cả a và b có giá trị 250 , nhưng nếu bạn xem kỹ b , nó là một chuỗi (nó được bao quanh bởi dấu ngoặc kép). Trong trường hợp này, $gte trả về false . Nếu chúng tôi đã sử dụng $lte thay vào đó, toán tử này sẽ trả về true .

Tài liệu 5 cũng sử dụng giá trị 250, nhưng một giá trị là số kép và giá trị kia là số thập phân. Bất kể, chúng đều tương đương và $gte trả về true .

Tương tự, tài liệu 6 trả về true bởi vì cả hai giá trị đều tương đương nhau, mặc dù một giá trị sử dụng vị trí thập phân một cách rõ ràng còn giá trị kia thì không.

Tài liệu 7 trả về true bởi vì, mặc dù giá trị ngày / giờ trong a lớn hơn giá trị trong b , họ sử dụng các kiểu khác nhau để thể hiện ngày đó (a sử dụng chuỗi ngày / giờ và b sử dụng đối tượng Ngày). Nếu chúng tôi đã sử dụng $lte thay vào đó, toán tử này sẽ trả về true do lệnh so sánh BSON.

Giá trị rỗng

$gte Có thể so sánh với null . Và so sánh null thành null trả về true .

Giả sử chúng tôi thêm các tài liệu sau vào bộ sưu tập của mình:

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

Hãy áp dụng $gte đối với các tài liệu đó:

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

Kết quả:

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

Các trường bị thiếu

Nếu một trong các trường bạn đang cố gắng so sánh bị thiếu, hãy $gte trả về true nếu trường thứ hai bị thiếu và false nếu cái đầu tiên bị thiếu.

Giả sử chúng tôi thêm các tài liệu sau vào bộ sưu tập của mình:

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

Hãy áp dụng $gte đối với các tài liệu đó:

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

Kết quả:

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

Vô cực

So sánh Infinity thành Infinity trả về true .

So sánh -Infinity thành -Infinity trả về true .

So sánh Infinity thành -Infinity trả về true .

So sánh -Infinity thành Infinity trả về false .

Giả sử chúng tôi thêm các tài liệu sau vào bộ sưu tập của mình:

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

Hãy áp dụng $gte đối với các tài liệu đó:

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

Kết quả:

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