MongoDB $setIntersection

V MongoDB, $setIntersection Operátor agregačního kanálu přijímá dvě nebo více polí a vrací pole obsahující prvky, které se objevují ve všech vstupních polích.

$setIntersection přijímá dva nebo více argumentů, z nichž všechny mohou být libovolným platným výrazem, pokud se každý z nich převede na pole. $setIntersection zachází s poli jako s množinami.

Příklad

Předpokládejme, že máme kolekci nazvanou data s následujícími dokumenty:

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

Můžeme použít $setIntersection operátor proti a a b pole v těchto dokumentech.

Příklad:

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

Výsledek:

{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2, 3 ], "výsledek" :[ 1, 2, 3 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2 ], "výsledek" :[ 1, 2 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2, 3 ], "výsledek" :[ 1, 2 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ], "výsledek" :[ 3 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 4, 5, 6 ], "výsledek" :[ ] }

Vnořená pole

$setIntersection operátor nesestupuje do žádných vnořených polí. Vyhodnocuje pouze pole nejvyšší úrovně.

Předpokládejme, že naše sbírka obsahuje také následující dokumenty:

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

A použijeme $setIntersection k těmto dvěma dokumentům:

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

Výsledek:

{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ], "výsledek" :[ ] }{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2 ], 3 ], "výsledek" :[ 3 ] }

V prvním dokumentu b pole obsahovalo pole, které obsahovalo pouze jeden prvek – další pole. V tomto případě bylo vyhodnoceno vnější pole a bylo zjištěno, že ne obsahovat libovolnou z hodnot, které byly v poli v a .

Předpokládejme však, že máme následující dokumenty:

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

Dokument 8 obsahuje vnořené pole v a a b pole a obě pole jsou identická.

Zde je to, co se stane, když použijeme $setIntersection k těm dokumentům:

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

Výsledek:

{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ], "výsledek" :[ [ 1, 2, 3 ] ] }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "výsledek" :[ ] }

V prvním dokumentu a odpovídá b přesně, takže výsledkem je identické pole (vnější pole obsahující vnitřní pole).

Ve druhém dokumentu je obsah a neodpovídá žádnému obsahu b , a tak se vrátí prázdné pole.

Chybějící pole

Použití $setIntersection na neexistující pole má za následek null .

Zvažte následující dokumenty:

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

 První dokument nemá b druhý dokument nemá a a třetí dokument nemá ani jedno.
 

 Zde je to, co se stane, když použijeme $setIntersection do a a b pole:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11, 12 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setIntersection: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Výsledek:
 
{ "a" :[ 1, 2, 3 ], "výsledek" :null }{ "b" :[ 1, 2, 3 ], "výsledek" :null }{ "výsledek" :null } 
Nesprávný datový typ
 

 Všechny operandy $setIntersection musí být pole. Pokud tomu tak není, dojde k chybě.
 

 Předpokládejme, že naše sbírka obsahuje následující dokumenty:
 
{ "_id" :13, "a" :[ 1, 2, 3 ], "b" :3 }{ "_id" :14, "a" :3, "b" :[ 1, 2, 3 ] }{ "_id" :15, "a" :2, "b" :3 }
 

 A použijeme $setIntersection k těm dokumentům:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setIntersection: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Výsledek:
 
Chyba:příkaz se nezdařil:{ "ok" :0, "errmsg" :"Všechny operandy $setIntersection musí být pole. Jeden argument je typu:double", "code" :17047, "codeName" :"Location17047 "} :agregace selhala :[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
 
Duplicitní hodnoty
 

 $setIntersection operátor ve svém výsledku odfiltruje duplikáty a vytvoří pole, které obsahuje pouze jedinečné položky. Také pořadí prvků ve výstupním poli není specifikováno.
 

 Předpokládejme, že máme následující dokumenty:
 
{ "_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" :[ ] }
 

 Poté použijeme $setIntersection operátor jim:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setIntersection: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Výsledek:
 
{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ], "výsledek" :[ 1, 2, 3 ] }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2 ], "výsledek" :[ 1, 2 ] }{ "a" :[ 1, 1, 2, 2, 3 , 3 ], "b" :[ ], "výsledek" :[ ] }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], " výsledek" :[ 1, 2, 3 ] }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], "výsledek" :[ 1, 2 ] } { "a" :[ 2, 3, 1, 2, 3, 1 ], "b" :[ ], "výsledek" :[ ] }
 
Více než dva argumenty
 

 Jak již bylo zmíněno, $setIntersection přijímá dva nebo více argumentů. Všechny předchozí příklady používaly dva argumenty. Zde je jeden, který používá tři argumenty.
 

 Předpokládejme, že máme následující dokumenty:
 
{ "_id" :22, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ] }{ "_id" :23, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ] }
 

 Tyto dokumenty mají další pole – c pole.
 

 Nyní použijeme $setIntersection do těchto tří polí:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 22, 23 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            c: 1,
            result: { $setIntersection: [ "$a", "$b", "$c" ] }
          }
     }
   ]
) 
 

 Výsledek:
 
{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ], "výsledek" :[ 1, 2 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ], "výsledek" :[ 1, 2 ] }