In MongoDB die $setIntersection Der Aggregationspipelineoperator akzeptiert zwei oder mehr Arrays und gibt ein Array zurück, das die Elemente enthält, die in allen Eingabearrays vorkommen.
$setIntersection akzeptiert zwei oder mehr Argumente, die alle ein beliebiger gültiger Ausdruck sein können, solange sie jeweils in ein Array aufgelöst werden. $setIntersection 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 den $setIntersection 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: { $setIntersection: [ "$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 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2, 3 ], "Ergebnis" :[ 1, 2 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ], "Ergebnis" :[ 3 ] }{ "a" :[ 1, 2, 3 ], "b" :[ 4, 5, 6 ], "Ergebnis" :[ ] } Verschachtelte Arrays
Die $setIntersection 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 ] }
Und wir wenden $setIntersection an zu diesen beiden Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 6, 7 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIntersection: [ "$a", "$b" ] }
}
}
]
) Ergebnis:
{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ], "Ergebnis" :[ ] }{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2 ], 3 ], "Ergebnis" :[ 3 ] }
Im ersten Dokument ist das b field enthielt ein Array, das nur ein Element enthielt – ein weiteres Array. In diesem Fall wurde das äußere Array ausgewertet und es wurde festgestellt, dass es nicht ist einen der Werte enthalten, die sich im Array unter a befanden .
Angenommen, wir haben die folgenden Dokumente:
{ "_id" :8, "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ] }{ "_id" :9, "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ] }
Dokument 8 enthält ein verschachteltes Array sowohl bei a und b Felder, und beide Arrays sind identisch.
Folgendes passiert, wenn wir $setIntersection anwenden zu diesen Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 8, 9 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIntersection: [ "$a", "$b" ] }
}
}
]
) Ergebnis:
{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ], "Ergebnis" :[ [ 1, 2, 3 ] ] }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "Ergebnis" :[ ] }
Im ersten Dokument a entspricht b genau, und daher ist das Ergebnis ein identisches Array (ein äußeres Array, das das innere Array enthält).
Im zweiten Dokument der Inhalt von a stimmt mit keinem der Inhalte von b überein , und daher wird ein leeres Array zurückgegeben.
Fehlende Felder
Anwenden von $setIntersection 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 $setIntersection anwenden zum a und b Felder:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 10, 11, 12 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIntersection: [ "$a", "$b" ] }
}
}
]
)
Ergebnis:
{ "a" :[ 1, 2, 3 ], "Ergebnis" :null }{ "b" :[ 1, 2, 3 ], "Ergebnis" :null }{ "Ergebnis" :null } Falscher Datentyp
Alle Operanden von $setIntersection 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 $setIntersection an zu diesen Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 13, 14, 15 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIntersection: [ "$a", "$b" ] }
}
}
]
)
Ergebnis:
Fehler:Befehl fehlgeschlagen:{ "ok" :0, "errmsg" :"Alle Operanden von $setIntersection müssen Arrays sein. Ein Argument ist vom Typ:double", "code" :17047, "codeName" :"Location17047 "} :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 $setIntersection -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, 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 $setIntersection an Operator zu ihnen:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIntersection: [ "$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, 2 ], "Ergebnis" :[ 1, 2 ] }{ "a" :[ 1, 1, 2, 2, 3 , 3 ], "b" :[ ], "Ergebnis" :[ ] }{ "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 ] } { "a" :[ 2, 3, 1, 2, 3, 1 ], "b" :[ ], "Ergebnis" :[ ] } Mehr als zwei Argumente
Wie bereits erwähnt, $setIntersection 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 ] }
Diese Dokumente haben ein zusätzliches Feld – ein c Feld.
Wenden wir nun $setIntersection an zu diesen drei Feldern:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 22, 23 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
c: 1,
result: { $setIntersection: [ "$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 ] }
