V MongoDB, $setDifference operátor agregačního kanálu přijímá dvě sady a provádí relativní doplněk druhé sady vzhledem k první. Vrací pole obsahující prvky, které existují pouze v první sadě.
$setDifference přijímá dva argumenty, přičemž oba mohou být libovolným platným výrazem, pokud se každý převede na pole. $setDifference 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 $setDifference 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: { $setDifference: [ "$a", "$b" ] }
}
}
]
) Výsledek:
{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2, 3 ], "výsledek" :[ ] }{ "a" :[ 1, 2, 3 ], "b " :[ 1, 2 ], "výsledek" :[ 3 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2, 3 ], "výsledek" :[ ] }{ "a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ], "výsledek" :[ 1, 2 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 4 , 5, 6 ], "výsledek" :[ 1, 2, 3 ] } Vnořená pole
$setDifference 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 $setDifference k těmto dvěma dokumentům:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 6, 7 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$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" :[ 1, 2 ] }
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 neobsahuje stejné hodnoty, jaké byly v poli na a .
Pokud však a pole obsahovalo samo vnořené pole, mohl to být jiný příběh.
Předpokládejme, ž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 ] }
A použijeme $setDifference k těm dokumentům:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 8, 9 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$a", "$b" ] }
}
}
]
) Výsledek:
{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ], "výsledek" :[ ] }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "výsledek" :[ [ 1, 2, 3 ] ] }
V prvním dokumentu a odpovídá b přesně, takže výsledkem je prázdné pole.
Ve druhém dokumentu je vnořené pole v a se liší od vnořeného pole v b , a tak celé vnořené pole z a je vráceno.
Chybějící pole
Použití $setDifference 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 $setDifference do a a b pole:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 10, 11, 12 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$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
Oba operandy $setDifference 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 $setDifference k těm dokumentům:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 13, 14, 15 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$a", "$b" ] }
}
}
]
)
Výsledek:
nezachycená výjimka:Chyba:příkaz se nezdařil:{ "ok" :0, "errmsg" :"oba operandy $setDifference musí být pole. Druhý argument je typu:double", "code" :17049, "codeName" :"Location17049"} :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
$setDifference 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 $setDifference operátor jim:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$a", "$b" ] }
}
}
]
)
Výsledek:
{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ], "výsledek" :[ ] }{ "a" :[ 1, 1 , 2, 2, 3, 3 ], "b" :[ 1, 2 ], "výsledek" :[ 3 ] }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ ], "výsledek" :[ 1, 2, 3 ] }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], "výsledek" :[ ] }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], "výsledek" :[ 3 ] }{ "a" :[ 2, 3 , 1, 2, 3, 1 ], "b" :[ ], "výsledek" :[ 2, 3, 1 ] }