MongoDB $setIntersection

Di MongoDB, $setIntersection operator pipa agregasi menerima dua atau lebih larik dan mengembalikan larik yang berisi elemen yang muncul di semua larik masukan.

$setIntersection menerima dua argumen atau lebih, yang semuanya dapat berupa ekspresi apa pun yang valid selama masing-masing diselesaikan ke array. $setIntersection memperlakukan array sebagai set.

Contoh

Misalkan kita memiliki koleksi yang disebut data dengan dokumen sebagai berikut:

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

Kita dapat menerapkan $setIntersection operator terhadap a dan b bidang dalam dokumen tersebut.

Contoh:

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

Hasil:

{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2, 3 ], "hasil" :[ 1, 2, 3 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2 ], "hasil" :[ 1, 2 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2, 3 ], "hasil" :[ 1, 2 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ], "hasil" :[ 3 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 4, 5, 6 ], "hasil" :[ ] }

Array Bersarang

$setIntersection operator tidak turun ke array bersarang apa pun. Itu hanya mengevaluasi array tingkat atas.

Misalkan koleksi kita juga berisi dokumen-dokumen berikut:

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

Dan kami menerapkan $setIntersection ke dua dokumen itu:

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

Hasil:

{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ], "hasil" :[ ] }{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2 ], 3 ], "hasil" :[ 3 ] }

Pada dokumen pertama, b field berisi array yang hanya berisi satu elemen – array lain. Dalam hal ini, Array luar dievaluasi, dan ternyata tidak berisi salah satu nilai yang ada dalam larik di a .

Namun, misalkan kita memiliki dokumen berikut:

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

Dokumen 8 berisi array bersarang di kedua a dan b bidang, dan kedua lariknya identik.

Inilah yang terjadi ketika kita menerapkan $setIntersection ke dokumen-dokumen itu:

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

Hasil:

{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ], "hasil" :[ [ 1, 2, 3 ] ] }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "hasil" :[ ] }

Di dokumen pertama, a cocok dengan b persis, sehingga hasilnya adalah larik identik (array luar berisi larik dalam).

Pada dokumen kedua, isi a tidak cocok dengan salah satu konten b , dan array kosong dikembalikan.

Bidang Tidak Ada

Menerapkan $setIntersection ke bidang yang tidak ada menghasilkan null .

Perhatikan dokumen berikut:

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

 Dokumen pertama tidak memiliki b bidang, dokumen kedua tidak memiliki a bidang, dan dokumen ketiga tidak memiliki keduanya.
 

 Inilah yang terjadi ketika kita menerapkan $setIntersection ke a dan b bidang:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11, 12 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setIntersection: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Hasil:
 
{ "a" :[ 1, 2, 3 ], "hasil" :null }{ "b" :[ 1, 2, 3 ], "hasil" :null }{ "hasil" :null } 
Jenis Data Salah
 

 Semua operan $setIntersection harus berupa array. Jika tidak, kesalahan akan terjadi.
 

 Misalkan koleksi kami berisi dokumen-dokumen berikut:
 
{ "_id" :13, "a" :[ 1, 2, 3 ], "b" :3 }{ "_id" :14, "a" :3, "b" :[ 1, 2, 3 ] }{ "_id" :15, "a" :2, "b" :3 }
 

 Dan kami menerapkan $setIntersection ke dokumen-dokumen itu:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setIntersection: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Hasil:
 
Kesalahan:perintah gagal:{ "ok" :0, "errmsg" :"Semua operan $setIntersection harus berupa array. Satu argumen bertipe:double", "code" :17047, "codeName" :"Location17047 "} :agregat gagal :example@sqldat.com/mongo/shell/utils.js:25:13example@sqldat.com/mongo/shell/assert.js:18:14example@sqldat.com/mongo/shell/assert. js:639:17example@sqldat.com/mongo/shell/assert.js:729:16example@sqldat.com/mongo/shell/db.js:266:5example@sqldat.com/mongo/shell/collection.js:1058:12@(kulit)::1:1
 
Nilai Duplikat
 

 $setIntersection operator menyaring duplikat dalam hasilnya untuk menampilkan larik yang hanya berisi entri unik. Juga, urutan elemen dalam larik keluaran tidak ditentukan.
 

 Misalkan kita memiliki dokumen berikut:
 
{ "_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" :[ ] }
 

 Kemudian kita terapkan $setIntersection operator untuk mereka:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setIntersection: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Hasil:
 
{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ], "hasil" :[ 1, 2, 3 ] }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2 ], "hasil" :[ 1, 2 ] }{ "a" :[ 1, 1, 2, 2, 3 , 3 ], "b" :[ ], "hasil" :[ ] }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], " hasil" :[ 1, 2, 3 ] }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], "hasil" :[ 1, 2 ] } { "a" :[ 2, 3, 1, 2, 3, 1 ], "b" :[ ], "hasil" :[ ] }
 
Lebih dari Dua Argumen
 

 Seperti yang disebutkan, $setIntersection menerima dua atau lebih argumen. Semua contoh sebelumnya menggunakan dua argumen. Ini salah satu yang menggunakan tiga argumen.
 

 Misalkan kita memiliki dokumen berikut:
 
{ "_id" :22, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ] }{ "_id" :23, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ] }
 

 Dokumen-dokumen ini memiliki bidang tambahan – c lapangan.
 

 Sekarang mari kita terapkan $setIntersection ke tiga bidang itu:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 22, 23 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            c: 1,
            result: { $setIntersection: [ "$a", "$b", "$c" ] }
          }
     }
   ]
) 
 

 Hasil:
 
{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ], "hasil" :[ 1, 2 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ], "hasil" :[ 1, 2 ] }