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

Trong MongoDB, $lte 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ó nhỏ 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 $lte 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: { $lte: [ "$a", "$b" ] }
          }
     }
   ]
)

Kết quả:

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

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ự nhỏ 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à false (bởi vì a không nhỏ hơn hoặc bằng b ).

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

So sánh các loại

$lte 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" : 250 }
{ "_id" : 6, "a" : 250, "b" : NumberDecimal("250") }
{ "_id" : 7, "a" : NumberDecimal("250"), "b" : 250 }
{ "_id" : 8, "a" : NumberDecimal("250"), "b" : NumberDecimal("250.00") }
{ "_id" : 9, "a" : NumberDecimal("250.00"), "b" : NumberDecimal("250") }
{ "_id" : 10, "a" : "2022-01-03T23:30:15.100Z", "b" : ISODate("2021-01-03T23:30:15.100Z") }
{ "_id" : 11, "a" : ISODate("2021-01-03T23:30:15.100Z"), "b" : "2021-01-03T23:30:15.100Z" }

Đây là những gì sẽ xảy ra khi chúng tôi áp dụng $lte 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, 8, 9, 10, 11 ] } } },
     {
       $project:
          {
            a: 1,
            b: 1,
            result: { $lte: [ "$a", "$b" ] }
          }
     }
   ]
).pretty()

Kết quả:

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

Giá trị rỗng

$lte 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" : 12, "a" : 250, "b" : null }
{ "_id" : 13, "a" : null, "b" : 250 }
{ "_id" : 14, "a" : null, "b" : null }

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

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

Kết quả:

{ "a" : 250, "b" : null, "result" : false }
{ "a" : null, "b" : 250, "result" : true }
{ "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 $lte trả về false nếu trường thứ hai bị thiếu và true 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" : 15, "a" : 250 }
{ "_id" : 16, "b" : 250 }

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

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

Kết quả:

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

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ề false .

So sánh -Infinity thành Infinity 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" : 17, "a" : Infinity, "b" : Infinity }
{ "_id" : 18, "a" : -Infinity, "b" : -Infinity }
{ "_id" : 19, "a" : Infinity, "b" : -Infinity }
{ "_id" : 20, "a" : -Infinity, "b" : Infinity }

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

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 17, 18, 19, 20 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $lte: [ "$a", "$b" ] }
          }
     }
   ]
)

Kết quả:

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