MongoDB $ strcasecmp

Trong MongoDB, $strcasecmp nhà điều hành đường ống tổng hợp thực hiện so sánh không phân biệt chữ hoa chữ thường của hai chuỗi.

Nó trả về 1 , 0 hoặc -1 , tùy thuộc vào việc chuỗi đầu tiên có lớn hơn, bằng hoặc nhỏ hơn chuỗi thứ hai hay không.

Cụ thể, $strcasecmp lợi nhuận:

• 1 nếu chuỗi đầu tiên lớn hơn chuỗi thứ hai
• 0 nếu cả hai chuỗi bằng nhau
• -1 nếu chuỗi đầu tiên nhỏ hơn chuỗi thứ hai

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" : "abc", "b" : "def" }
{ "_id" : 2, "a" : "abc", "b" : "abc" }
{ "_id" : 3, "a" : "def", "b" : "abc" }
{ "_id" : 4, "a" : "abc", "b" : "cba" }
{ "_id" : 5, "a" : "cba", "b" : "abc" }

Đây là những gì sẽ xảy ra khi chúng tôi áp dụng $strcasecmp đối với các tài liệu đó:

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

Kết quả:

{ "a" : "abc", "b" : "def", "result" : -1 }
{ "a" : "abc", "b" : "abc", "result" : 0 }
{ "a" : "def", "b" : "abc", "result" : 1 }
{ "a" : "abc", "b" : "cba", "result" : -1 }
{ "a" : "cba", "b" : "abc", "result" : 1 }

Phân biệt chữ hoa chữ thường

Như đã đề cập, $strcasecmp thực hiện so sánh không phân biệt chữ hoa chữ thường.

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

{ "_id" : 6, "a" : "ABC", "b" : "abc" }

a trường chứa một chuỗi chữ hoa và b trường chứa cùng một chuỗi nhưng ở dạng chữ thường.

Đây là những gì sẽ xảy ra khi chúng tôi áp dụng $strcasecmp cho cả hai trường:

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

Kết quả:

{ "a" : "ABC", "b" : "abc", "result" : 0 }

Kết quả là 0 , có nghĩa là cả hai chuỗi đều bằng nhau.

Nói cách khác, so sánh không phân biệt chữ hoa chữ thường.

Giá trị rỗng

$strcasecmp coi hai giá trị rỗng là bằng nhau. Ngoài ra, một chuỗi được coi là lớn hơn null .

Giả sử chúng ta có các tài liệu sau trong bộ sưu tập của mình:

{ "_id" : 7, "a" : "abc", "b" : null }
{ "_id" : 8, "a" : null, "b" : "abc" }
{ "_id" : 9, "a" : null, "b" : null }

Đây là những gì sẽ xảy ra khi chúng tôi áp dụng $strcasecmp đối với các tài liệu đó:

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

Kết quả:

{ "a" : "abc", "b" : null, "result" : 1 }
{ "a" : null, "b" : "abc", "result" : -1 }
{ "a" : null, "b" : null, "result" : 0 }

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

Các trường bị thiếu có tác dụng tương tự như null .

Hãy thêm các tài liệu sau vào bộ sưu tập của chúng tôi:

{ "_id" : 10, "a" : "abc" }
{ "_id" : 11, "b" : "abc" }
{ "_id" : 12 }

Đây là những gì sẽ xảy ra khi chúng tôi áp dụng $strcasecmp cho họ:

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

Kết quả:

{ "a" : "abc", "result" : 1 }
{ "b" : "abc", "result" : -1 }
{ "result" : 0 }

Các loại dữ liệu khác

Các kiểu dữ liệu khác có thể được so sánh, miễn là chúng có thể phân giải thành một chuỗi.

Dưới đây là một loạt tài liệu chứa nhiều kiểu dữ liệu khác nhau:

{ "_id" : 13, "a" : 123, "b" : 456 }
{ "_id" : 14, "a" : 123, "b" : 123 }
{ "_id" : 15, "a" : 456, "b" : 123 }
{ "_id" : 16, "a" : NumberDecimal("123"), "b" : NumberDecimal("456") }
{ "_id" : 17, "a" : NumberDecimal("123"), "b" : NumberDecimal("123") }
{ "_id" : 18, "a" : NumberDecimal("456"), "b" : NumberDecimal("123") }
{ "_id" : 19, "a" : ISODate("1999-01-03T23:30:15.100Z"), "b" : "2000-01-03T23:30:15.100Z" }
{ "_id" : 20, "a" : ISODate("2000-01-03T23:30:15.100Z"), "b" : "2000-01-03T23:30:15.100Z" }
{ "_id" : 21, "a" : ISODate("2000-01-03T23:30:15.100Z"), "b" : "1999-01-03T23:30:15.100Z" }

Và đây là những gì sẽ xảy ra khi chúng tôi áp dụng $strcasecmp đối với các tài liệu đó:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15, 16, 17, 18, 19, 20, 21 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
).pretty()

Kết quả:

{ "a" : 123, "b" : 456, "result" : -1 }
{ "a" : 123, "b" : 123, "result" : 0 }
{ "a" : 456, "b" : 123, "result" : 1 }
{ "a" : NumberDecimal("123"), "b" : NumberDecimal("456"), "result" : -1 }
{ "a" : NumberDecimal("123"), "b" : NumberDecimal("123"), "result" : 0 }
{ "a" : NumberDecimal("456"), "b" : NumberDecimal("123"), "result" : 1 }
{
	"a" : ISODate("1999-01-03T23:30:15.100Z"),
	"b" : "2000-01-03T23:30:15.100Z",
	"result" : -1
}
{
	"a" : ISODate("2000-01-03T23:30:15.100Z"),
	"b" : "2000-01-03T23:30:15.100Z",
	"result" : 0
}
{
	"a" : ISODate("2000-01-03T23:30:15.100Z"),
	"b" : "1999-01-03T23:30:15.100Z",
	"result" : 1
}