I MongoDB, $setDifference aggregeringspipelineoperatören accepterar två uppsättningar och utför ett relativt komplement av den andra uppsättningen relativt den första. Den returnerar en array som innehåller de element som bara finns i den första uppsättningen.
$setDifference accepterar två argument, som båda kan vara vilket giltigt uttryck som helst så länge som var och en löser sig till en array. $setDifference behandlar arrayerna som uppsättningar.
Exempel
Anta att vi har en samling som heter data med följande dokument:
{ "_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 ] }
Vi kan använda $setDifference operatorn mot a och b fält i dessa dokument.
Exempel:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$a", "$b" ] }
}
}
]
) Resultat:
{ "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 ], "resultat" :[ 1, 2 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 4 , 5, 6 ], "result" :[ 1, 2, 3 ] } Inkapslade arrayer
$setDifference operatorn går inte ner i några kapslade arrayer. Den utvärderar bara arrayer på toppnivå.
Anta att vår samling också innehåller följande dokument:
{ "_id" :6, "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ] }{ "_id" :7, "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2 ], 3 ] }
Och vi tillämpar $setDifference till dessa två dokument:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 6, 7 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$a", "$b" ] }
}
}
]
) Resultat:
{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ], "result" :[ 1, 2, 3 ] }{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2 ], 3 ], "resultat" :[ 1, 2 ] }
I det första dokumentet, b fältet innehöll en array som bara innehöll ett element – en annan array. I det här fallet utvärderades den yttre arrayen, och den visade sig inte innehålla samma värden som fanns i arrayen vid a .
Men om a fältet hade innehållit en kapslad array i sig, kan det ha varit en annan historia.
Anta att vi har följande dokument:
{ "_id" :8, "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ] }{ "_id" :9, "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ] }
Och vi tillämpar $setDifference till dessa dokument:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 8, 9 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$a", "$b" ] }
}
}
]
) Resultat:
{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ], "result" :[ ] }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "resultat" :[ [ 1, 2, 3 ] ] }
I det första dokumentet, a matchar b exakt, och så resultatet är en tom array.
I det andra dokumentet, den kapslade arrayen vid a skiljer sig från den kapslade arrayen vid b , och så hela den kapslade arrayen från a returneras.
Fält saknas
Använder $setDifference till ett icke-existerande fält resulterar i null .
Tänk på följande dokument:
{ "_id" :10, "a" :[ 1, 2, 3 ] }{ "_id" :11, "b" :[ 1, 2, 3 ] }{ "_id" :12 }
Det första dokumentet har ingen b fältet har det andra dokumentet ingen a och det tredje dokumentet har inte heller.
Det här är vad som händer när vi använder $setDifference till a och b fält:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 10, 11, 12 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$a", "$b" ] }
}
}
]
)
Resultat:
{ "a" :[ 1, 2, 3 ], "result" :null }{ "b" :[ 1, 2, 3 ], "result" :null }{ "result" :null } Fel datatyp
Båda operanderna för $setDifference måste vara arrayer. Om de inte är det skapas ett felmeddelande.
Anta att vår samling innehåller följande dokument:
{ "_id" :13, "a" :[ 1, 2, 3 ], "b" :3 }{ "_id" :14, "a" :3, "b" :[ 1, 2, 3 ] }{ "_id" :15, "a" :2, "b" :3 }
Och vi tillämpar $setDifference till dessa dokument:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 13, 14, 15 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$a", "$b" ] }
}
}
]
)
Resultat:
oupptäckt undantag:Fel:kommando misslyckades:{ "ok" :0, "errmsg" :"båda operanderna för $setDifference måste vara arrayer. Det andra argumentet är av typen:double", "code" :17049, "codeName" :"Location17049"} :sammanställning misslyckades :[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 Duplicera värden
$setDifference operatören filtrerar bort dubbletter i sitt resultat för att mata ut en array som bara innehåller unika poster. Ordningen på elementen i utgångsmatrisen är också ospecificerad.
Anta att vi har följande dokument:
{ "_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" :[ ] }
Sedan tillämpar vi $setDifference operatör till dem:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setDifference: [ "$a", "$b" ] }
}
}
]
)
Resultat:
{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ], "result" :[ ] }{ "a" :[ 1, 1 , 2, 2, 3, 3 ], "b" :[ 1, 2 ], "resultat" :[ 3 ] }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ ], "resultat" :[ 1, 2, 3 ] }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], "resultat" :[ ] }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], "resultat" :[ 3 ] }{ "a" :[ 2, 3 , 1, 2, 3, 1 ], "b" :[ ], "resultat" :[ 2, 3, 1 ] }