In MongoDB die $setUnion Der Aggregations-Pipeline-Operator akzeptiert zwei oder mehr Arrays und gibt ein Array zurück, das die Elemente enthält, die in einem dieser Eingabe-Arrays vorkommen.
$setUnion akzeptiert zwei oder mehr Argumente, die alle ein beliebiger gültiger Ausdruck sein können, solange sie jeweils in ein Array aufgelöst werden. $setUnion behandelt die Arrays als Sets.
Beispiel
Angenommen, wir haben eine Sammlung namens data mit folgenden Dokumenten:
{ "_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 ] }
Wir können $setUnion anwenden Operator gegen a und b Felder in diesen Dokumenten.
Beispiel:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setUnion: [ "$a", "$b" ] }
}
}
]
) Ergebnis:
{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2, 3 ], "Ergebnis" :[ 1, 2, 3 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2 ], "Ergebnis" :[ 1, 2, 3 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2, 3 ], "Ergebnis " :[ 1, 2, 3 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ], "Ergebnis" :[ 1, 2, 3, 4, 5 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 4, 5, 6 ], "Ergebnis" :[ 1, 2, 3, 4, 5, 6 ] } Verschachtelte Arrays
Die $setUnion Der Operator steigt nicht in verschachtelte Arrays ab. Es wertet nur Arrays der obersten Ebene aus.
Angenommen, unsere Sammlung enthält auch die folgenden Dokumente:
{ "_id" :6, "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ] }{ "_id" :7, "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2 ], 3 ] }{ "_id" :8, "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ] }{ "_id" :9, "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ] }
Und wir wenden $setUnion an zu diesen beiden Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 6, 7, 8, 9 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setUnion: [ "$a", "$b" ] }
}
}
]
) Ergebnis:
{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ], "Ergebnis" :[ 1, 2, 3, [ 1, 2, 3 ] ] } { "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2 ], 3 ], "Ergebnis" :[ 1, 2, 3, [ 1, 2 ] ] }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ], "Ergebnis" :[ [ 1, 2, 3 ] ] }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "Ergebnis" :[ 3, [ 1, 2 ], [ 1, 2, 3 ] ] } Fehlende Felder
Anwenden von $setUnion zu einem nicht existierenden Feld ergibt null .
Betrachten Sie die folgenden Dokumente:
{ "_id" :10, "a" :[ 1, 2, 3 ] }{ "_id" :11, "b" :[ 1, 2, 3 ] }{ "_id" :12 }
Das erste Dokument hat kein b Feld hat das zweite Dokument kein a Feld, und das dritte Dokument hat beides nicht.
Folgendes passiert, wenn wir $setUnion anwenden zum a und b Felder:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 10, 11, 12 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setUnion: [ "$a", "$b" ] }
}
}
]
)
Ergebnis:
{ "a" :[ 1, 2, 3 ], "Ergebnis" :null }{ "b" :[ 1, 2, 3 ], "Ergebnis" :null }{ "Ergebnis" :null } Falscher Datentyp
Alle Operanden von $setUnion müssen Arrays sein. Wenn dies nicht der Fall ist, wird ein Fehler ausgegeben.
Angenommen, unsere Sammlung enthält die folgenden Dokumente:
{ "_id" :13, "a" :[ 1, 2, 3 ], "b" :3 }{ "_id" :14, "a" :3, "b" :[ 1, 2, 3 ] }{ "_id" :15, "a" :2, "b" :3 }
Und wir wenden $setUnion an zu diesen Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 13, 14, 15 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setUnion: [ "$a", "$b" ] }
}
}
]
)
Ergebnis:
Fehler:Befehl fehlgeschlagen:{ "ok" :0, "errmsg" :"Alle Operanden von $setUnion müssen Arrays sein. Ein Argument ist vom Typ:double", "code" :17043, "codeName" :"Location17043 "} :Aggregat fehlgeschlagen :[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 Doppelte Werte
Die $setUnion -Operator filtert Duplikate in seinem Ergebnis heraus, um ein Array auszugeben, das nur eindeutige Einträge enthält. Außerdem ist die Reihenfolge der Elemente im Ausgabearray nicht festgelegt.
Angenommen, wir haben die folgenden Dokumente:
{ "_id" :16, "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ] }{ "_id" :17, "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 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" :[ ] }
Dann wenden wir den $setUnion an Operator zu ihnen:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setUnion: [ "$a", "$b" ] }
}
}
]
)
Ergebnis:
{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ], "Ergebnis" :[ 1, 2, 3 ] }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 1, 2 ], "Ergebnis" :[ 1, 2, 3 ] }{ "a" :[ 1, 1, 2 , 2, 3, 3 ], "b" :[ ], "Ergebnis" :[ 1, 2, 3 ] }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], "Ergebnis" :[ 1, 2, 3 ] }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], " Ergebnis" :[ 1, 2, 3 ] }{ "a" :[ 2, 3, 1, 2, 3, 1 ], "b" :[ ], "Ergebnis" :[ 1, 2, 3 ] } Mehr als zwei Argumente
Wie bereits erwähnt, $setUnion akzeptiert zwei oder mehr Argumente. Alle vorherigen Beispiele verwendeten zwei Argumente. Hier ist eines, das drei Argumente verwendet.
Angenommen, wir haben die folgenden Dokumente:
{ "_id" :22, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ] }{ "_id" :23, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ] }{ "_id" :24, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 4, 5 ] }
Diese Dokumente haben ein zusätzliches Feld – ein c Feld.
Wenden wir nun $setUnion an zu diesen drei Feldern:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 22, 23, 24 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
c: 1,
result: { $setUnion: [ "$a", "$b", "$c" ] }
}
}
]
)
Ergebnis:
{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ], "Ergebnis" :[ 1, 2 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ], "Ergebnis" :[ 1, 2, 3 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 4, 5 ], "Ergebnis" :[ 1, 2, 4, 5 ] }
