V MongoDB, $setEquals operátor agregačního kanálu porovná dvě nebo více polí a vrátí true pokud mají stejné odlišné prvky a false jinak.
$setEquals 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. $setEquals 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 $setEquals 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: { $setEquals: [ "$a", "$b" ] }
}
}
]
) Výsledek:
{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2, 3 ], "výsledek" :true }{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2 ], "výsledek" :nepravda }{ "a" :[ 1, 2 ], "b" :[ 1, 2, 3 ], "výsledek" :nepravda }{ "a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ], "výsledek" :nepravda }{ "a" :[ 1, 2, 3 ], "b" :[ 4, 5, 6 ], "výsledek " :nepravda } Vnořená pole
$setEquals 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 $setEquals k těmto dvěma dokumentům:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 6, 7 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setEquals: [ "$a", "$b" ] }
}
}
]
) Výsledek:
{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ], "výsledek" :false }{ "a" :[ 1, 2, 3 ], " b" :[ [ 1, 2 ], 3 ], "výsledek" :nepravda }
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 $setEquals k těm dokumentům:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 8, 9 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setEquals: [ "$a", "$b" ] }
}
}
]
) Výsledek:
{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ], "výsledek" :true }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "výsledek" :nepravda }
V prvním dokumentu a odpovídá b přesně, takže výsledek je true .
Ve druhém dokumentu je vnořené pole v a se liší od vnořeného pole v b , a tak dostaneme false .
Chybějící pole
Použití $setEquals na neexistující pole vede k chybě.
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 $setEquals do a a b pole:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 10, 11, 12 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setEquals: [ "$a", "$b" ] }
}
}
]
)
Výsledek:
Chyba:příkaz se nezdařil:{ "ok" :0, "errmsg" :"Všechny operandy $setEquals musí být pole. Jeden argument je typu:chybí", "code" :17044, "codeName" :"Location17044 "} :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
Jak je uvedeno ve zprávě, všechny operandy musí být pole. Chybějící argument/pole není pole.
Nesprávný datový typ
Jak je vidět v předchozím příkladu, všechny operandy $setEquals musí být pole. Pokud pole, na které odkazují, chybí, je vyvolána chyba. Ke stejné chybě dochází, když operand nechybí, ale je prostě nesprávného typu.
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 $setEquals k těm dokumentům:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 13, 14, 15 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setEquals: [ "$a", "$b" ] }
}
}
]
)
Výsledek:
Chyba:příkaz se nezdařil:{ "ok" :0, "errmsg" :"Všechny operandy $setEquals musí být pole. Jeden argument je typu:double", "code" :17044, "codeName" :"Location17044 "} :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
$setEquals operátor ignoruje duplicitní položky. Také ignoruje pořadí prvků.
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" :[ ] }
Potom použijeme $setEquals operátor jim:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setEquals: [ "$a", "$b" ] }
}
}
]
)
Výsledek:
{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ], "výsledek" :true }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2 ], "výsledek" :nepravda }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ ] , "výsledek" :nepravda }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], "výsledek" :pravda }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], "výsledek" :nepravda }{ "a" :[ 2, 3, 1, 2, 3, 1 ], "b " :[ ], "výsledek" :nepravda } Více než dva argumenty
Jak již bylo zmíněno, $setEquals přijímá dva nebo více argumentů. Ve všech případech musí mít argumenty stejné odlišné hodnoty, aby vrátily hodnotu true . V opačném případě bude výsledek false .
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 $setEquals do těchto tří polí:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 22, 23 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
c: 1,
result: { $setEquals: [ "$a", "$b", "$c" ] }
}
}
]
)
Výsledek:
{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ], "výsledek" :true }{ "a" :[ 1, 2 ] , "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ], "výsledek" :nepravda }