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

Trong MongoDB, $or toán tử đường ống tổng hợp đánh giá một hoặc nhiều biểu thức và trả về true nếu có đánh giá thành true . Nếu không, nó trả về false .

Cú pháp

Cú pháp như sau:

{ $or: [ <expression1>, <expression2>, ... ] }

Ví dụ

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

{ "_id" : 1, "a" : 10, "b" : 2, "c" : 20 }

Đây là những gì sẽ xảy ra khi chúng tôi sử dụng $or để kiểm tra hai điều kiện đối với tài liệu đó:

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $or: [ 
              { $gt: [ "$a", 9 ] }, 
              { $lt: [ "$b", 1 ] }
            ] } 
          } 
         }
   ]
)

Kết quả:

{ "a" : 10, "b" : 2, "result" : true }

Chúng ta có thể thấy rằng $or trả về true , ngay cả khi một trong các biểu thức giải quyết thành false . Điều này là do nó trả về true nếu bất kỳ trong số các biểu thức là true .

Đây là một lần nữa, nhưng với cả hai biểu thức phân giải thành false .

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $or: [ 
              { $gt: [ "$a", 20 ] }, 
              { $lt: [ "$b", 1 ] }
            ] } 
          } 
         }
   ]
)

Kết quả:

{ "a" : 10, "b" : 2, "result" : false }

Nhiều hơn hai đối số

Như đã đề cập, $or chấp nhận một hoặc nhiều biểu thức. Ví dụ trước sử dụng hai biểu thức. Dưới đây là một ví dụ sử dụng ba:

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        c: 1,
        result: { $or: [ 
              { $gt: [ "$a", 9 ] }, 
              { $lt: [ "$b", 3 ] }, 
              { $gt: [ "$c", 30 ] } 
            ] } 
          } 
         }
   ]
)

Kết quả:

{ "a" : 10, "b" : 2, "c" : 20, "result" : true }

Trong trường hợp này, kết quả là true , ngay cả khi giá trị thứ ba đánh giá là false .

Một đối số

Cho rằng $or chấp nhận một hoặc nhiều biểu thức, có thể cung cấp một đối số duy nhất.

Ví dụ:

db.data.aggregate(
   [
     { $match: { _id: 1 } },
     { $project: { 
        _id: 0,
        a: 1,
        result: { $or: [ 
              { $gt: [ "$a", 9 ] }
            ] } 
          } 
         }
   ]
)

Kết quả:

{ "a" : 10, "result" : true }

Các giá trị bằng 0, rỗng và không xác định

$or toán tử đánh giá 0 , null và undefined dưới dạng false .

Giả sử chúng ta có các tài liệu sau:

{ "_id" : 2, "a" : 0, "b" : 2 }
{ "_id" : 3, "a" : 10, "b" : 0 }
{ "_id" : 4, "a" : 0, "b" : 0 }
{ "_id" : 5, "a" : null, "b" : 2 }
{ "_id" : 6, "a" : 10, "b" : null }
{ "_id" : 7, "a" : null, "b" : null }
{ "_id" : 8, "a" : undefined, "b" : 2 }
{ "_id" : 9, "a" : 10, "b" : undefined }
{ "_id" : 10, "a" : undefined, "b" : undefined }

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

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        b: 1,
        result: { $or: [ "$a", "$b" ] } }
         }
   ]
)

Kết quả:

{ "a" : 0, "b" : 2, "result" : true }
{ "a" : 10, "b" : 0, "result" : true }
{ "a" : 0, "b" : 0, "result" : false }
{ "a" : null, "b" : 2, "result" : true }
{ "a" : 10, "b" : null, "result" : true }
{ "a" : null, "b" : null, "result" : false }
{ "a" : undefined, "b" : 2, "result" : true }
{ "a" : 10, "b" : undefined, "result" : true }
{ "a" : undefined, "b" : undefined, "result" : false }

Ở đây, tôi chỉ đơn giản sử dụng trường làm biểu thức.

Đây là giao diện khi chúng tôi chỉ áp dụng một đối số cho các trường chứa 0 , null và undefined :

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 4, 7, 10 ] } } },
     { $project: { 
        _id: 0,
        a: 1,
        result: { $or: [ "$a" ] } }
         }
   ]
)

Kết quả:

{ "a" : 0, "result" : false }
{ "a" : null, "result" : false }
{ "a" : undefined, "result" : false }

Tất cả các trường đều trả về false .

Gọi $or Không có Đối số

Khi được gọi mà không có đối số, $or toán tử đánh giá thành false .

Ví dụ:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1 ] } } },
     { $project: { 
        _id: 0,
        result: { $or: [ ] } }
         }
   ]
)

Kết quả:

{ "result" : false }