In MongoDB das $setIsSubset Der Aggregations-Pipeline-Operator akzeptiert zwei Arrays und gibt true zurück wenn das erste Array eine Teilmenge des zweiten ist, und false wenn es nicht ist.
Das erste Array wird auch als Teilmenge betrachtet, wenn es gleich dem zweiten Array ist.
$setIsSubset akzeptiert zwei Argumente, die beide ein beliebiger gültiger Ausdruck sein können, solange sie jeweils in ein Array aufgelöst werden. $setIsSubset 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 das $setIsSubset 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: { $setIsSubset: [ "$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" :wahr }{ "a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ], "Ergebnis" :falsch }{ "a" :[ 1, 2, 3 ], "b" :[ 4, 5, 6 ], "Ergebnis " :falsch } Verschachtelte Arrays
Das $setIsSubset 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 $setIsSubset an zu diesen beiden Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 6, 7 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$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 festgestellt, dass a ist keine Teilmenge von b .
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 $setIsSubset anwenden zu diesen Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 8, 9 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$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 a ist keine Teilmenge von b , also ist das Ergebnis false .
Fehlende Felder
Anwenden von $setIsSubset 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 $setIsSubset anwenden zum a und b Felder:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 10, 11, 12 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$a", "$b" ] }
}
}
]
)
Ergebnis:
Fehler:Befehl fehlgeschlagen:{ "ok" :0, "errmsg" :"beide Operanden von $setIsSubset müssen Arrays sein. Zweites Argument ist vom Typ:missing", "code" :17042, "codeName" :"Location17042 "} :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 Falscher Datentyp
Beide Operanden von $setIsSubset 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 $setIsSubset an zu diesen Dokumenten:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 13, 14, 15 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$a", "$b" ] }
}
}
]
)
Ergebnis:
Fehler:Befehl fehlgeschlagen:{ "ok" :0, "errmsg" :"beide Operanden von $setIsSubset müssen Arrays sein. Zweites Argument ist vom Typ:double", "code" :17042, "codeName" :"Location17042 "} :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
Das $setIsSubset Operator ignoriert Duplikate. 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 das $setIsSubset an Operator zu ihnen:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
{
$project:
{
_id: 0,
a: 1,
b: 1,
result: { $setIsSubset: [ "$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 }
