In MongoDB die $setEquals Der Aggregations-Pipeline-Operator vergleicht zwei oder mehr Arrays und gibt true zurück wenn sie die gleichen unterschiedlichen Elemente und false haben andernfalls.
$setEquals akzeptiert zwei oder mehr Argumente, die alle ein beliebiger gültiger Ausdruck sein können, solange sie jeweils in ein Array aufgelöst werden. $setEquals 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 $setEquals 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: { $setEquals: [ "$a", "$b" ] }
}
}
]
) Ergebnis:
{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2, 3 ], "Ergebnis" :wahr }{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2 ], "Ergebnis" :falsch }{ "a" :[ 1, 2 ], "b" :[ 1, 2, 3 ], "Ergebnis" :falsch }{ "a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ], "Ergebnis" :falsch }{ "a" :[ 1, 2, 3 ], "b" :[ 4, 5, 6 ], "Ergebnis " :falsch } Verschachtelte Arrays
Die $setEquals 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 $setEquals an zu diesen beiden Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 6, 7 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setEquals: [ "$a", "$b" ] }
}
}
]
) Ergebnis:
{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ], "Ergebnis" :false }{ "a" :[ 1, 2, 3 ], " b" :[ [ 1, 2 ], 3 ], "Ergebnis" :falsch }
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 die gleichen Werte enthält wie das Array bei a .
Wenn jedoch a -Feld selbst ein verschachteltes Array enthalten hätte, wäre es vielleicht eine andere Geschichte gewesen.
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 ] }
Und wir wenden $setEquals an zu diesen Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 8, 9 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setEquals: [ "$a", "$b" ] }
}
}
]
) Ergebnis:
{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ], "Ergebnis" :wahr }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "Ergebnis" :falsch }
Im ersten Dokument a entspricht b genau, also ist das Ergebnis true .
Im zweiten Dokument das verschachtelte Array bei a unterscheidet sich von dem verschachtelten Array bei b , und so erhalten wir false .
Fehlende Felder
Anwenden von $setEquals auf ein nicht vorhandenes Feld führt zu einem Fehler.
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 $setEquals anwenden zum a und b Felder:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 10, 11, 12 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setEquals: [ "$a", "$b" ] }
}
}
]
)
Ergebnis:
Fehler:Befehl fehlgeschlagen:{ "ok" :0, "errmsg" :"Alle Operanden von $setEquals müssen Arrays sein. Ein Argument ist vom Typ:fehlt", "code" :17044, "codeName" :"Location17044 "} :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
Wie die Nachricht besagt, müssen alle Operanden Arrays sein. Ein fehlendes Argument/Feld ist kein Array.
Falscher Datentyp
Wie im vorherigen Beispiel zu sehen, alle Operanden von $setEquals müssen Arrays sein. Wenn das Feld, auf das sie sich beziehen, fehlt, wird ein Fehler ausgegeben. Derselbe Fehler tritt auf, wenn der Operand nicht fehlt, sondern einfach vom falschen Typ ist.
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 $setEquals an zu diesen Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 13, 14, 15 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setEquals: [ "$a", "$b" ] }
}
}
]
)
Ergebnis:
Fehler:Befehl fehlgeschlagen:{ "ok" :0, "errmsg" :"Alle Operanden von $setEquals müssen Arrays sein. Ein Argument ist vom Typ:double", "code" :17044, "codeName" :"Location17044 "} :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 $setEquals Operator ignoriert doppelte Einträge. Es ignoriert auch die Reihenfolge der Elemente.
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 $setEquals an Operator zu ihnen:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setEquals: [ "$a", "$b" ] }
}
}
]
)
Ergebnis:
{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ], "Ergebnis" :wahr }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2 ], "Ergebnis" :falsch }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ ] , "Ergebnis" :falsch }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], "Ergebnis" :wahr }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], "Ergebnis" :falsch }{ "a" :[ 2, 3, 1, 2, 3, 1 ], "b " :[ ], "Ergebnis" :falsch } Mehr als zwei Argumente
Wie bereits erwähnt, $setEquals akzeptiert zwei oder mehr Argumente. In allen Fällen müssen die Argumente dieselben unterschiedlichen Werte haben, um true zurückzugeben . Andernfalls ist das Ergebnis false .
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 $setEquals an zu diesen drei Feldern:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 22, 23 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
c: 1,
result: { $setEquals: [ "$a", "$b", "$c" ] }
}
}
]
)
Ergebnis:
{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ], "Ergebnis" :wahr }{ "a" :[ 1, 2 ] , "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ], "Ergebnis" :falsch }
