MongoDB $ setDifference

Trong MongoDB, $setDifference toán tử đường ống tổng hợp chấp nhận hai tập hợp và thực hiện bổ sung tương đối của tập hợp thứ hai so với tập hợp đầu tiên. Nó trả về một mảng chứa các phần tử chỉ tồn tại trong tập hợp đầu tiên.

$setDifference chấp nhận hai đối số, cả hai đều có thể là bất kỳ biểu thức hợp lệ nào miễn là mỗi đối số phân giải thành một mảng. $setDifference coi các mảng là tập hợp.

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":[1, 2, 3], "b":[1, 2, 3]} {"_id":2, "a":[1, 2, 3], "b":[1, 2]} {"_id":3, "a":[1, 2], "b":[1, 2, 3]} {"_id":4, " a ":[1, 2, 3]," b ":[3, 4, 5]} {" _id ":5," a ":[1, 2, 3]," b ":[4, 5 , 6]} 

Chúng tôi có thể áp dụng $setDifference toán tử so với a và b các trường trong các tài liệu đó.

Ví dụ:

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

Kết quả:

 {"a":[1, 2, 3], "b":[1, 2, 3], "result":[]} {"a":[1, 2, 3], "b ":[1, 2]," result ":[3]} {" a ":[1, 2]," b ":[1, 2, 3]," result ":[]} {" a " :[1, 2, 3], "b":[3, 4, 5], "result":[1, 2]} {"a":[1, 2, 3], "b":[4 , 5, 6], "kết quả":[1, 2, 3]} 

Mảng lồng nhau

$setDifference toán tử không đi xuống bất kỳ mảng lồng nhau nào. Nó chỉ đánh giá các mảng cấp cao nhất.

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

 {"_id":6, "a":[1, 2, 3], "b":[[1, 2, 3]]} {"_id":7, "a":[1, 2, 3], "b":[[1, 2], 3]} 

Và chúng tôi áp dụng $setDifference cho hai tài liệu đó:

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

Kết quả:

 {"a":[1, 2, 3], "b":[[1, 2, 3]], "result":[1, 2, 3]} {"a":[1, 2, 3], "b":[[1, 2], 3], "kết quả":[1, 2]} 

Trong tài liệu đầu tiên, b trường chứa một mảng chỉ chứa một phần tử - một mảng khác. Trong trường hợp này, Mảng bên ngoài đã được đánh giá và nó được phát hiện là không chứa các giá trị giống như trong mảng tại a .

Tuy nhiên, nếu a trường đã chứa một mảng lồng nhau, nó có thể là một câu chuyện khác.

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

 {"_id":8, "a":[[1, 2, 3]], "b":[[1, 2, 3]]} {"_id":9, "a":[ [1, 2, 3]], "b":[[1, 2], 3]} 

Và chúng tôi áp dụng $setDifference đối với các tài liệu đó:

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

Kết quả:

 {"a":[[1, 2, 3]], "b":[[1, 2, 3]], "result":[]} {"a":[[1, 2, 3]], "b":[[1, 2], 3], "kết quả":[[1, 2, 3]]} 

Trong tài liệu đầu tiên, a khớp với b chính xác, và do đó kết quả là một mảng trống.

Trong tài liệu thứ hai, mảng lồng nhau tại a khác với mảng lồng nhau tại b , và toàn bộ mảng lồng nhau từ a được trả lại.

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

Áp dụng $setDifference đến một trường không tồn tại dẫn đến null .

Xem xét các tài liệu sau:

 {"_id":10, "a":[1, 2, 3]} {"_id":11, "b":[1, 2, 3]} {"_id":12}  

 Tài liệu đầu tiên không có b trường, tài liệu thứ hai không có a và tài liệu thứ ba cũng không có. 
 

 Đây là những gì sẽ xảy ra khi chúng tôi áp dụng $setDifference tới a và b lĩnh vực:
 
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11, 12 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setDifference: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Kết quả:
 
 {"a":[1, 2, 3], "result":null} {"b":[1, 2, 3], "result":null} {"result":null}  
 Loại dữ liệu sai 
 

 Cả hai toán hạng của $setDifference phải là mảng. Nếu không, một lỗi sẽ xảy ra. 
 

 Giả sử bộ sưu tập của chúng tôi chứa các tài liệu sau:
 
 {"_id":13, "a":[1, 2, 3], "b":3} {"_id":14, "a":3, "b":[1, 2, 3]} {"_id":15, "a":2, "b":3} 
 

 Và chúng tôi áp dụng $setDifference đối với các tài liệu đó:
 
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setDifference: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Kết quả:
 
 uncaught exception:Error:command failed:{"ok":0, "errmsg":"cả hai toán hạng của $ setDifference phải là mảng. Đối số thứ hai thuộc loại:double", "code":17049, "codeName" :"Location17049"}:tổng hợp không thành công:[email protected]/mongo/shell/utils.js:25:[email protected]/mongo/shell/assert.js:18:[email protected]/mongo/shell /assert.js:639:[email protected]/mongo/shell/assert.js:729:[email protected]/mongo/shell/db.js:266:[email protected]/mongo/shell/collection .js:1058:12 @ (shell):1:1 
 
 Giá trị trùng lặp 
 

 $setDifference toán tử lọc ra các bản sao trong kết quả của nó để xuất ra một mảng chỉ chứa các mục nhập duy nhất. Ngoài ra, thứ tự của các phần tử trong mảng đầu ra là không xác định. 
 

 Giả sử chúng ta có các tài liệu sau:
 
 {"_id":16, "a":[1, 1, 2, 2, 3, 3], "b":[1, 2, 3]} {"_id":17, "a" :[1, 1, 2, 2, 3, 3], "b":[1, 2]} {"_id":18, "a":[1, 1, 2, 2, 3, 3], "b":[]} {"_id":19, "a":[3, 2, 1, 2, 3, 1], "b":[2, 3, 1]} {"_id":20 , "a":[1, 3, 2, 2, 3, 1], "b":[2, 1]} {"_id":21, "a":[2, 3, 1, 2, 3 , 1], "b":[]} 
 

 Sau đó, chúng tôi áp dụng $setDifference toán tử cho họ:
 
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setDifference: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Kết quả:
 
 {"a":[1, 1, 2, 2, 3, 3], "b":[1, 2, 3], "result":[]} {"a":[1, 1 , 2, 2, 3, 3], "b":[1, 2], "result":[3]} {"a":[1, 1, 2, 2, 3, 3], "b" :[], "result":[1, 2, 3]} {"a":[3, 2, 1, 2, 3, 1], "b":[2, 3, 1], "result" :[]} {"a":[1, 3, 2, 2, 3, 1], "b":[2, 1], "result":[3]} {"a":[2, 3 , 1, 2, 3, 1], "b":[], "result":[2, 3, 1]}