MongoDB<\/a> ist eine NoSQL-Datenbanksoftware, die dokumentenorientierte Informationen verwaltet.<\/p>\nEine der wichtigsten Eigenschaften von MongoDB ist ihre Geschwindigkeit. Um Abfragen schneller zu beantworten, kann MongoDB Operatoren verwenden, um bestimmte Funktionen auszuf\u00fchren.<\/p>\n
Operatoren sind spezielle Symbole, die Compilern helfen, mathematische oder logische Aufgaben auszuf\u00fchren. MongoDB bietet mehrere Arten von Operatoren, um mit der Datenbank zu interagieren.<\/p>\n
MongoDB-Operator-Typen<\/h2>\n Es gibt neun Arten von Operatoren, die jeweils nach ihrer Funktion benannt sind. Logische Operatoren zum Beispiel verwenden logische Operationen. Um sie auszuf\u00fchren, musst du ein bestimmtes Schl\u00fcsselwort verwenden und die Syntax beachten. Sie sind jedoch ziemlich einfach zu verstehen!<\/p>\n
Am Ende dieses Artikels wirst du die Grundlagen der einzelnen Operatoren und ihrer Funktionen kennenlernen.<\/p>\n
Logische Operatoren<\/h3>\n Logische Operatoren werden oft verwendet, um Daten nach bestimmten Bedingungen zu filtern. Sie erm\u00f6glichen auch die Auswertung vieler Bedingungen, auf die wir noch n\u00e4her eingehen werden.<\/p>\n
Im Folgenden findest du einige logische Operatoren, die du verwenden kannst:<\/p>\n
$und<\/h4>\n Eine „und“-Bedingung f\u00fchrt eine logische „und“-Operation mit einem Array aus zwei oder mehr Ausdr\u00fccken durch. Sie w\u00e4hlt die Dokumente aus, bei denen alle<\/em> Bedingungen der Ausdr\u00fccke erf\u00fcllt sind.<\/p>\nDies ist die Standardsyntax f\u00fcr den Ausdruck $and<\/code>:<\/p>\n{ $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }<\/code><\/pre>\ndb.inventory.find( { $and: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )<\/code><\/pre>\n$oder<\/h4>\n Eine „oder“-Bedingung f\u00fchrt eine logische „oder“-Operation an einem Array aus zwei oder mehr Ausdr\u00fccken durch. Sie w\u00e4hlt die Dokumente aus, bei denen mindestens einer der Ausdr\u00fccke wahr ist.<\/p>\n
Dies ist die Standardsyntax f\u00fcr den Ausdruck $or<\/code>:<\/p>\n{ $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }.<\/code><\/pre>\nWenn wir zum Beispiel Dokumente ausw\u00e4hlen wollen, bei denen der Preis $10 oder die Menge weniger als 15 betr\u00e4gt, k\u00f6nnen wir die folgende Abfrage eingeben:<\/p>\n
db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )<\/code><\/pre>\nWir m\u00fcssen den Ausdruck nicht auf zwei Kriterien beschr\u00e4nken – wir k\u00f6nnen weitere hinzuf\u00fcgen. Die folgende Abfrage w\u00e4hlt zum Beispiel die Dokumente aus, bei denen der Preis gleich $10 ist, die Menge unter 15 liegt oder das Tag station\u00e4r ist:<\/p>\n
db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 }, { tag: \"stationary\" }] } )<\/code><\/pre>\nWenn diese Klauseln ausgef\u00fchrt werden, f\u00fchrt MongoDB entweder einen Collection Scan oder einen Index Scan durch. Wenn alle Indizes die Klauseln unterst\u00fctzen, verwendet MongoDB Indizes, um einen $or<\/code> Ausdruck zu \u00fcberpr\u00fcfen. Andernfalls verwendet es stattdessen einen Collection Scan.<\/p>\nWenn du jedoch die Kriterien im selben Feld pr\u00fcfen willst, solltest du den $in<\/code> Operator statt des $or<\/code> Operators verwenden. Wenn du zum Beispiel eine Sammlung von Dokumenten suchst, bei denen die Menge entweder 20 oder 50 betr\u00e4gt, musst du stattdessen die folgende $in<\/code> Abfrage ausf\u00fchren:<\/p>\ndb.inventory.find ( { quantity: { $in: [20, 50] } } )<\/code><\/pre>\nAuf den $in<\/code> Operator gehen wir sp\u00e4ter noch genauer ein.<\/p>\n$nor<\/h4>\n Dieser Operator f\u00fchrt eine logische „nor“-Operation auf einem Array mit einem oder mehreren Ausdr\u00fccken durch. Anschlie\u00dfend w\u00e4hlt er die Dokumente aus, die die Abfrageausdr\u00fccke nicht erf\u00fcllen. Einfacher ausgedr\u00fcckt: Er macht das Gegenteil der $or<\/code> Bedingung.<\/p>\nDies ist die allgemeine Syntax:<\/p>\n
{ $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }<\/code><\/pre>\nBetrachten wir die folgende Abfrage:<\/p>\n
db.inventory.find( { $nor: [ { price: 3.99 }, { sale: true } ] } )<\/code><\/pre>\nDiese Abfrage w\u00e4hlt die Dokumente aus, die enthalten:<\/p>\n
\nein Preisfeldwert ungleich $3,99 und ein Verkaufswert ungleich true; oder<\/li>\n ein Preisfeld mit einem Wert ungleich $3,99 und ein leeres oder fehlendes Verkaufsfeld; oder<\/li>\n kein Preisfeld und ein Verkaufsfeld, das nicht gleich wahr ist; oder<\/li>\n weder ein Preisfeld noch ein Verkaufsfeld ausgef\u00fcllt oder vorhanden ist.<\/li>\n<\/ul>\n$nicht<\/h4>\n Dieser Operator f\u00fchrt eine logische „Nicht“-Operation auf einem Array f\u00fcr den angegebenen Ausdruck durch. Er w\u00e4hlt dann die Dokumente aus, die nicht mit den Abfrageausdr\u00fccken \u00fcbereinstimmen. Dazu geh\u00f6ren auch die Dokumente, die das Feld nicht enthalten.<\/p>\n
Dies ist die allgemeine Syntax:<\/p>\n
{ field: { $not: { <operator-expression> } } }<\/code><\/pre>\nNimm zum Beispiel die folgende Abfrage:<\/p>\n
db.inventory.find( { price: { $not: { $lt: 3.99 } } } )<\/code><\/pre>\nDiese Abfrage w\u00fcrde die Dokumente ausw\u00e4hlen, die Folgendes enthalten:<\/p>\n
\nein Preisfeld, dessen Wert gr\u00f6\u00dfer oder gleich $3,99 ist; und<\/li>\n ein Preisfeld, dass nicht ausgef\u00fcllt ist oder nicht existiert.<\/li>\n<\/ul>\n\n Info<\/h3>\n { $not: { $lt: 3.99 } }<\/code> unterscheidet sich vom $gte<\/code> Operator. { $gte: 3.99 }<\/code> gibt nur die Dokumente zur\u00fcck, in denen das Preisfeld existiert und sein Wert gr\u00f6\u00dfer oder gleich $3.99 ist (der Operator $not<\/code> gibt auch die Dokumente zur\u00fcck, in denen das Preisfeld nicht existiert).<\/p>\n<\/aside>\n\nVergleichsoperatoren<\/h3>\n Vergleichsoperatoren k\u00f6nnen verwendet werden, um Werte in einem oder mehreren Dokumenten zu vergleichen.<\/p>\n
Im Folgenden findest du ein Codebeispiel f\u00fcr eine einfache Bestandserfassung f\u00fcr einen Supermarkt:<\/p>\n
{ _id: 1, item: { name: \"apple\", code: \"123\" }, qty: 15, tags: [ \"A\", \"B\", \"C\" ] },\n{ _id: 2, item: { name: \"banana\", code: \"123\" }, qty: 20, tags: [ \"B\" ] },\n{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] },\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] },\n{ _id: 5, item: { name: \"pears\", code: \"000\" }, qty: 20, tags: [ [ \"A\", \"B\" ], \"C\" ] },\n{ _id: 6, item: { name: \"strawberry\", code: \"123\" }, tags: [ \"B\" ] }<\/code><\/pre>\nAnhand dieses Beispiels werden wir im Folgenden die einzelnen Vergleichsoperatoren n\u00e4her erl\u00e4utern.<\/p>\n
Gleich ($eq)<\/h4>\n Dieser Operator vergleicht Werte, die gleich dem angegebenen Wert sind:<\/p>\n
{ <field>: { $eq: <value> } }<\/code><\/pre>\nWenn wir zum Beispiel ein bestimmtes Dokument aus der Bestandssammlung abrufen wollen, das genau den Mengenwert „20“ hat, geben wir den folgenden Befehl ein:<\/p>\n
db.inventory.find( { qty: { $eq: 20 } } )<\/code><\/pre>\nDie Abfrage w\u00fcrde das Folgende zur\u00fcckgeben:<\/p>\n
{ _id: 2, item: { name: \"banana\", code: \"123\" }, qty: 20, tags: [ \"B\" ] }, \n{ _id: 5, item: { name: \"pears\", code: \"000\" }, qty: 20, tags: [ [ \"A\", \"B\" ], \"C\" ] }<\/code><\/pre>\nGr\u00f6\u00dfer als ($gt)<\/h4>\n Dieser Operator passt, wenn die Werte gr\u00f6\u00dfer sind als der angegebene Wert:<\/p>\n
{ field: { $gt: value } }<\/code><\/pre>\nIn diesem Beispiel finden wir die Dokumente, bei denen die Menge gr\u00f6\u00dfer als 15 ist:<\/p>\n
db.inventory.find({\"qty\": { $gt: 15}})<\/code><\/pre>\nDie Abfrage w\u00fcrde Folgendes ergeben:<\/p>\n
{ _id: 2, item: { name: \"banana\", code: \"123\" }, qty: 20, tags: [ \"B\" ] }\n{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] }\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] }\n{ _id: 5, item: { name: \"pears\", code: \"000\" }, qty: 20, tags: [ [ \"A\", \"B\" ], \"C\" ] }<\/code><\/pre>\nKleiner als ($lt)<\/h4>\n Dieser Operator passt, wenn die Werte kleiner sind als der angegebene Wert:<\/p>\n
{ field: { $lt: value } }<\/code><\/pre>\nLass uns die Dokumente mit einer Anzahl von weniger als 25 finden:<\/p>\n
db.inventory.find({\"qty\": { $lt: 25}})<\/code><\/pre>\nDie Abfrage w\u00fcrde Folgendes ergeben:<\/p>\n
{ _id: 1, item: { name: \"apple\", code: \"123\" }, qty: 15, tags: [ \"A\", \"B\", \"C\" ] }\n{ _id: 2, item: { name: \"banana\", code: \"123\" }, qty: 20, tags: [ \"B\" ] }\n{ _id: 5, item: { name: \"pears\", code: \"000\" }, qty: 20, tags: [ [ \"A\", \"B\" ], \"C\" ] }<\/code><\/pre>\nGr\u00f6\u00dfer oder gleich ($gte)<\/h4>\n Dieser Operator passt, wenn die Werte gr\u00f6\u00dfer oder gleich dem angegebenen Wert sind:<\/p>\n
{ field: { $gte: value } }<\/code><\/pre>\nIn diesem Beispiel suchen wir die Dokumente, bei denen die Menge gr\u00f6\u00dfer oder gleich 25 ist:<\/p>\n
db.inventory.find({\"qty\": { $gte: 25}})<\/code><\/pre>\nDiese Abfrage w\u00fcrde das Folgende zur\u00fcckgeben:<\/p>\n
{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] }\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] }<\/code><\/pre>\nKleiner oder gleich ($lte)<\/h4>\n Dieser Operator passt nur, wenn die Werte kleiner oder gleich dem angegebenen Wert sind:<\/p>\n
{ field: { $lte: value } }<\/code><\/pre>\nSuchen wir die Dokumente, deren Anzahl kleiner oder gleich 25 ist.<\/p>\n
db.inventory.find({\"qty\": { $lte: 25}})<\/code><\/pre>\nWir k\u00f6nnen erwarten, dass diese Abfrage das Folgende zur\u00fcckgibt:<\/p>\n
{ _id: 1, item: { name: \"apple\", code: \"123\" }, qty: 15, tags: [ \"A\", \"B\", \"C\" ] }\n{ _id: 2, item: { name: \"banana\", code: \"123\" }, qty: 20, tags: [ \"B\" ] }\n{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] }\n{ _id: 5, item: { name: \"pears\", code: \"000\" }, qty: 20, tags: [ [ \"A\", \"B\" ], \"C\" ] }<\/code><\/pre>\nIn ($in)<\/h4>\n Dieser Operator gibt die Dokumente zur\u00fcck, die mit den angegebenen Werten \u00fcbereinstimmen:<\/p>\n
{ field: { $in: [<value1>, <value2>, ... <valueN> ] } }<\/code><\/pre>\nDer Wert eines Feldes entspricht einem beliebigen Wert in dem angegebenen Array. Um zum Beispiel die Dokumente mit den Werten „30“ und „15“ in der Inventarsammlung abzurufen, w\u00fcrdest du so vorgehen:<\/p>\n
db.inventory.find({ \"qty\": { $in: [30, 15]}})<\/code><\/pre>\nDie Ausgabe w\u00fcrde lauten:<\/p>\n
{ _id: 1, item: { name: \"apple\", code: \"123\" }, qty: 15, tags: [ \"A\", \"B\", \"C\" ] }\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] }<\/code><\/pre>\nNicht in ($nin)<\/h4>\n Dieser Operator gibt die Dokumente zur\u00fcck, die nicht mit den angegebenen Werten \u00fcbereinstimmen. Hier ist die grundlegende Syntax des $nin<\/code> Operators:<\/p>\n{ field: { $nin: [ <value1>, <value2> ... <valueN> ]<\/code><\/pre>\n$nin<\/code> w\u00e4hlt die Dokumente aus, bei denen:<\/p>\n\nder Feldwert nicht im angegebenen Array enthalten ist; oder<\/li>\n das Feld nicht existiert.<\/li>\n<\/ul>\nWenn das Feld Arrays enth\u00e4lt, w\u00e4hlt es Arrays aus, in denen kein Element aus dem Wertebereich vorhanden ist. Wir wollen zum Beispiel die Dokumente ausw\u00e4hlen, bei denen die Menge nicht gleich 20 oder 15 ist.<\/p>\n
Au\u00dferdem werden auch Dokumente ausgew\u00e4hlt, die kein Mengenfeld enthalten:<\/p>\n
db.inventory.find({ \"qty\": { $nin: [ 20, 15 ]}})<\/code><\/pre>\nDie Ausgabe w\u00fcrde lauten:<\/p>\n
{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] }\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] }\n{ _id: 6, item: { name: \"strawberry\", code: \"123\" }, tags: [ \"B\" ] }<\/code><\/pre>\nNicht gleich ($ne)<\/h4>\n Der $ne<\/code> Operator gibt die Dokumente zur\u00fcck, bei denen der angegebene Wert nicht gleich ist:<\/p>\n{ $ne: value } }<\/code><\/pre>\nNehmen wir an, wir wollen alle Dokumente ausw\u00e4hlen, bei denen die Menge nicht gleich 20 ist:<\/p>\n
db.inventory.find( { qty: { $ne: 20 } } )<\/code><\/pre>\nDie Ausgabe w\u00fcrde lauten:<\/p>\n
{ _id: 1, item: { name: \"apple\", code: \"123\" }, qty: 15, tags: [ \"A\", \"B\", \"C\" ] }\n{ _id: 3, item: { name: \"spinach\", code: \"456\" }, qty: 25, tags: [ \"A\", \"B\" ] }\n{ _id: 4, item: { name: \"lentils\", code: \"456\" }, qty: 30, tags: [ \"B\", \"A\" ] }\n{ _id: 6, item: { name: \"strawberry\", code: \"123\" }, tags: [ \"B\" ] }<\/code><\/pre>\nAnhand der obigen Ausgabe k\u00f6nnen wir sehen, dass die Abfrage Dokumente ausw\u00e4hlt, die kein Mengenfeld haben.<\/p>\n
Element-Operatoren<\/h3>\n Mit den Elementabfrageoperatoren k\u00f6nnen Dokumente anhand der Felder des Dokuments identifiziert werden. Die Elementoperatoren bestehen aus $exist<\/code> und $type<\/code>.<\/p>\n$exists<\/h4>\n Dieser Operator findet Dokumente, die ein bestimmtes Feld haben. Dieser Operator hat einen booleschen Wert, der entweder true<\/code> oder false<\/code> sein kann.<\/p>\nWenn der Wert true<\/code> ist, werden alle Dokumente gefunden, die das Feld enthalten, einschlie\u00dflich der Dokumente, in denen der Feldwert Null ist. Wenn <boolean> false<\/code> ist, gibt die Abfrage nur die Dokumente zur\u00fcck, die das Feld nicht enthalten.<\/p>\nHier ist die Standardsyntax:<\/p>\n
{ field: { $exists: <boolean> } } )<\/code><\/pre>\nNehmen wir ein Beispiel, in dem wir eine Sammlung von Daten f\u00fcr ein Array mit dem Namen „bagofmarbles“ haben, in dem jede T\u00fcte Murmeln in verschiedenen Farben enth\u00e4lt:<\/p>\n
{ red: 5, green: 5, blue: null }\n{ red: 3, green: null, blue: 8 }\n{ red: null, green: 3, blue: 9 }\n{ red: 1, green: 2, blue: 3 }\n{ red: 2, blue: 5 }\n{ red: 3, green: 2 }\n{ red: 4 }\n{ green: 2, blue: 4 }\n{ green: 2 }\n{ blue: 6 }<\/code><\/pre>\nNehmen wir an, wir wollen eine Abfrage, die nur die Beutel zur\u00fcckgibt, in denen sich rote Murmeln befinden. Das bedeutet, dass wir den booleschen Wert als true<\/code> eingeben m\u00fcssen. Schauen wir uns das mal an:<\/p>\ndb.bagofmarbles.find( { red: { $exists: true } } )<\/code><\/pre>\nDie Ergebnisse w\u00fcrden aus den Dokumenten bestehen, die das Feld „rot“ enthalten, auch wenn der Wert null<\/code> w\u00e4re. Allerdings w\u00fcrden sie nicht aus den Dokumenten bestehen, in denen das Feld „rot“ gar nicht existiert:<\/p>\n{ red: 5, green: 5, blue: null }\n{ red: 3, green: null, blue: 8 }\n{ red: null, green: 3, blue: 9 }\n{ red: 1, green: 2, blue: 3 }\n{ red: 2, blue: 5 }\n{ red: 3, green: 2 }\n{ red: 4 }<\/code><\/pre>\nWenn wir nur die Taschen haben wollen, in denen das Feld „rote Murmeln“ gar nicht vorkommt, k\u00f6nnen wir die folgende Abfrage eingeben:<\/p>\n
db.bagofmarbles.find( { red: { $exists: false} )<\/code><\/pre>\nDie Ergebnisse w\u00fcrden aus den Dokumenten bestehen, die das Feld „rot“ nicht enthalten:<\/p>\n
{ green: 2, blue: 4 }\n{ green: 2 }\n{ blue: 6 }<\/code><\/pre>\n$Typ<\/h4>\n Dieser Operator gleicht Dokumente nach dem angegebenen Feldtyp ab. Dies ist n\u00fctzlich, wenn du sehr unstrukturierte Daten hast oder wenn die Datentypen nicht vorhersehbar sind. Diese Feldtypen werden als BSON-Typen angegeben und k\u00f6nnen entweder durch eine Typnummer oder einen Alias definiert werden.<\/p>\n
Dies ist die allgemeine Syntax f\u00fcr $type<\/code>:<\/p>\n{ field: { $type: <BSON type> } }<\/code><\/pre>\nNehmen wir an, wir haben ein Adressbuch mit den folgenden Dokumenten:<\/p>\n
db={\n addressBook: [\n {\n \"_id\": 1,\n address: \"2100 Jupiter Spot\",\n zipCode: \"9036325\"\n },\n {\n \"_id\": 2,\n address: \"25 Moon Place\",\n zipCode: 26237\n },\n {\n \"_id\": 3,\n address: \"2324 Neptune Ring\",\n zipCode: NumberLong(77622222)\n },\n {\n \"_id\": 4,\n address: \"33 Saturns Moon\",\n zipCode: NumberInt(117)\n },\n {\n \"_id\": 5,\n address: \"1044 Venus Lane\",\n zipCode: [\n \"99883637232\",\n \"73488976234\"\n ]\n }\n ]\n}<\/code><\/pre>\nIn den oben genannten Dokumenten gibt es f\u00fcr die Postleitzahl verschiedene Datentypen. Dazu geh\u00f6ren Long-, Double-, Integer- und String-Werte.<\/p>\n
Wenn wir nur die Dokumente haben wollen, die einen bestimmten Datentyp als Postleitzahl haben – nehmen wir in diesem Fall String – m\u00fcssen wir die folgende Abfrage in den Compiler eingeben:<\/p>\n
db.addressBook.find({\n \"zipCode\": {\n $type: \"string\"\n }\n})<\/code><\/pre>\nDies w\u00fcrde die folgenden Dokumente zur\u00fcckgeben:<\/p>\n
[\n {\n \"_id\": 1,\n \"address\": \"2100 Jupiter Spot\",\n \"zipCode\": \"9036325\"\n },\n {\n \"_id\": 5,\n \"address\": \"1044 Venus Lane\",\n \"zipCode\": [\n \"99883637232\",\n \"73488976234\"\n ]\n }\n]<\/code><\/pre>\nAu\u00dferdem gibt es den Typ „number“, der alle Long-, Integer- oder Double-Werte als Array enth\u00e4lt, das ein Element der angegebenen Typen enth\u00e4lt:<\/p>\n
db.addressBook.find( { \"zipCode\" : { $type : \"number\" } } )<\/code><\/pre>\nAusgabe:<\/p>\n
[\n{\n \"_id\": 2,\n address: \"25 Moon Place\",\n zipCode: 26237\n },\n {\n \"_id\": 3,\n address: \"2324 Neptune Ring\",\n zipCode: NumberLong(77622222)\n },\n {\n \"_id\": 4,\n address: \"33 Saturns Moon\",\n zipCode: NumberInt(117)\n }\n]<\/code><\/pre>\nWenn die Dokumente einen Array-Feldtyp haben, gibt der $type<\/code> Operator die Dokumente zur\u00fcck, in denen mindestens ein Array-Element dem Typ entspricht, der dem Operator \u00fcbergeben wurde.<\/p>\n\n Info<\/h3>\n Ab MongoDB 3.6 gibt die Abfrage nach $type: \"array\"<\/code> Dokumente zur\u00fcck, bei denen das Feld selbst ein Array ist. Bei der gleichen Abfrage wurden in den vorherigen Versionen jedoch Dokumente zur\u00fcckgegeben, bei denen das Feld ein Array ist und mindestens ein Element vom Datentyp Array war.<\/p>\n<\/aside>\n\nArray-Operatoren<\/h3>\n MongoDB verf\u00fcgt auch \u00fcber Array-Operatoren, um Dokumente abzufragen, die Arrays enthalten.<\/p>\n
Es gibt drei Hauptoperatoren: $all<\/code>, $elemMatch<\/code> und $size<\/code>. Im Folgenden werden wir jeden einzelnen im Detail besprechen.<\/p>\n$all<\/h4>\n Der $all<\/code> Operator w\u00e4hlt die Dokumente aus, in denen der Wert eines Feldes ein Array mit den angegebenen Elementen ist:<\/p>\n{ : { $all: [ <value1> , <value2> ... ] } }<\/code><\/pre>\nNehmen wir zum Beispiel an, wir haben eine Sammlung von Dokumenten f\u00fcr ein Bekleidungsgesch\u00e4ft, die unter Inventar folgendes enthalten.<\/p>\n
{\n _id: ObjectId(\"5234cc89687ea597eabee675\"),\n code: \"shirt\",\n tags: [ \"sale\", \"shirt\", \"button\", \"y2k\", \"casual\" ],\n qty: [\n { size: \"S\", num: 10, color: \"blue\" },\n { size: \"M\", num: 45, color: \"blue\" },\n { size: \"L\", num: 100, color: \"green\" }\n ]\n},\n\n{\n _id: ObjectId(\"5234cc8a687ea597eabee676\"),\n code: \"pant\",\n tags: [ \"y2k\", \"trendy\", \"shine\" ],\n qty: [\n { size: \"6\", num: 100, color: \"green\" },\n { size: \"6\", num: 50, color: \"blue\" },\n { size: \"8\", num: 100, color: \"brown\" }\n ]\n},\n\n{\n _id: ObjectId(\"5234ccb7687ea597eabee677\"),\n code: \"pant2\",\n tags: [ \"trendy\", \"shine\" ],\n qty: [\n { size: \"S\", num: 10, color: \"blue\" },\n { size: \"M\", num: 100, color: \"blue\" },\n { size: \"L\", num: 100, color: \"green\" }\n ]\n},\n\n{\n _id: ObjectId(\"52350353b2eff1353b349de9\"),\n code: \"shirt2\",\n tags: [ \"y2k\", \"trendy\" ],\n qty: [\n { size: \"M\", num: 100, color: \"green\" }\n ]\n}<\/code><\/pre>\nWir m\u00f6chten alle Dokumente (in diesem Fall die Kleidung) aus dem Inventar abrufen, die mit den Tags „trendy“ und „y2k“ verkn\u00fcpft sind. Die folgende Abfrage verwendet den Operator $all<\/code>, wobei der Wert des Feldes tags ein Array ist, dessen Elemente „y2k“ und „trendy“ enthalten:<\/p>\ndb.inventory.find( { tags: { $all: [ \"y2k\", \"trendy\" ] } } )<\/code><\/pre>\nDie obige Abfrage gibt Folgendes zur\u00fcck:<\/p>\n
{\n _id: ObjectId(\"5234cc8a687ea597eabee676\"),\n code: \"pant\",\n tags: [ \"y2k\", \"trendy\", \"shine\" ],\n qty: [\n { size: \"6\", num: 100, color: \"green\" },\n { size: \"6\", num: 50, color: \"blue\" },\n { size: \"8\", num: 100, color: \"brown\" }\n ]\n}\n\n{\n _id: ObjectId(\"52350353b2eff1353b349de9\"),\n code: \"shirt2\",\n tags: [ \"y2k\", \"trendy\" ],\n qty: [\n { size: \"M\", num: 100, color: \"green\" }\n ]\n}<\/code><\/pre>\nAnhand des obigen Beispiels sehen wir auch, dass der $all<\/code> Operator einfach die gleiche Funktion wie die $and<\/code> Operation ausf\u00fchrt.<\/p>\nAlternativ k\u00f6nnten wir auch die folgende Abfrage verwenden, die ein \u00e4hnliches Ergebnis wie die obige liefert:<\/p>\n
db.inventory.find({\n $and: [\n {\n tags: \"y2k\"\n },\n {\n tags: \"trendy\"\n }\n ]\n})<\/code><\/pre>\n$elemMatch<\/h4>\n Der $elemMatch<\/code> Operator findet Dokumente, die ein Array-Feld mit mindestens einem Element enthalten, das allen angegebenen Abfragekriterien entspricht:<\/p>\n{ : { $elemMatch: { <query1>, <query2>, ... } } }<\/code><\/pre>\nW\u00e4hrend wir Vergleichsoperatoren wie $lte<\/code> und $gte<\/code> verwenden k\u00f6nnen, k\u00f6nnen wir, wenn wir nur eine einzige Abfragebedingung innerhalb von $elemMatch<\/code> angeben und weder $not<\/code> noch $ne<\/code> verwenden, $elemMatch<\/code> weglassen, da er im Wesentlichen dieselbe Funktion erf\u00fcllt.<\/p>\nBei der Verwendung dieses Operators gibt es noch ein paar weitere Dinge zu beachten, vor allem:<\/p>\n
\nDu kannst keinen $where<\/code> Ausdruck in einer $elemMatch<\/code> Operation angeben.<\/li>\nDu kannst keinen $text<\/code> Abfrageausdruck in einer $elemMatch<\/code> Operation angeben.<\/li>\n<\/ul>\nWir haben zum Beispiel die folgenden Dokumente in der Sammlung der Sch\u00fclerergebnisse:<\/p>\n
{ _id: 1, results: [ 92, 89, 98 ] }\n{ _id: 2, results: [ 85, 99, 99 ] }<\/code><\/pre>\nDie folgende Abfrage findet nur die Dokumente, bei denen das Ergebnisfeld mindestens ein Element enth\u00e4lt, das gr\u00f6\u00dfer oder gleich 90 und kleiner als 95 ist:<\/p>\n
db.studentresults.find( { results: { $elemMatch: { $gte: 90, $lt: 95 } } })<\/code><\/pre>\nUnsere Abfrage gibt das folgende Dokument zur\u00fcck, da das Element 92 sowohl gr\u00f6\u00dfer oder gleich 90 als auch kleiner als 95 ist:<\/p>\n
{ \"_id\" : 1, \"results\" :[ 92, 89, 98 ] }<\/code><\/pre>\n$size<\/h4>\n Der $size<\/code> Operator gibt die Dokumente zur\u00fcck, bei denen die Gr\u00f6\u00dfe des Arrays mit der Anzahl der im Argument angegebenen Elemente \u00fcbereinstimmt:<\/p>\n{ field: { $size: value } }<\/code><\/pre>\nHier ist ein Beispiel:<\/p>\n
db.collection.find( { field: { $size: 2 } });<\/code><\/pre>\nDies w\u00fcrde alle Dokumente in der angegebenen Sammlung zur\u00fcckgeben, bei denen das Feld ein Array mit 2 Elementen ist: { field: [ orange, apple] }<\/code> und { field: [ blue, red] }<\/code>, aber nicht { field: blue}<\/code> oder { field: [ raspberry, lemon, grapefruit ] }<\/code>.<\/p>\nWir k\u00f6nnen zwar einen bestimmten Wert als Gr\u00f6\u00dfe eingeben, aber wir k\u00f6nnen keine Wertebereiche als Gr\u00f6\u00dfe angeben.<\/p>\n
Geospatiale Operatoren<\/h3>\n MongoDB erm\u00f6glicht es dir, Geodaten in Form von GeoJSON-Typen zu speichern. GeoJSON ist ein auf der JavaScript-Objektnotation basierendes, offenes Standardformat, das geografische Merkmale darstellen kann und nicht-r\u00e4umliche Attribute unterst\u00fctzt. Es gibt zwei Arten von GeoJSON-Operatoren, \u00fcber die wir in diesem Artikel sprechen werden: Geometriespezifizierer und Abfrageselektoren.<\/p>\n
$geometry<\/h4>\n Dieser Operator gibt die GeoJSON-Geometrie f\u00fcr die Verwendung mit den folgenden Geodatenabfrageoperatoren an: $geoIntersects<\/code> $geoWithin<\/code> ,$nearSphere<\/code> und $near<\/code>. $geometry<\/code> verwendet EPSG:4326 als Standard-Koordinatenreferenzsystem (CRS).<\/p>\nUm GeoJSON-Objekte mit dem Standard-CRS anzugeben, kannst du das folgende Snippet f\u00fcr $geometry<\/code> verwenden:<\/p>\n$geometry: {\n type: \"<GeoJSON object type>\",\n coordinates: [ <coordinates> ]\n}<\/code><\/pre>\nUm ein einfaches GeoJSON-Polygon mit einem ma\u00dfgeschneiderten MongoDB-CRS zu erw\u00e4hnen, kannst du das folgende Snippet verwenden (du kannst es nur f\u00fcr $geoWithin<\/code> und $geoIntersects<\/code> verwenden):<\/p>\n$geometry: {\n type: \"Polygon\",\n coordinates: [ <coordinates> ],\n crs: {\n type: \"name\",\n properties: { name: \"urn:x-mongodb:crs:strictwinding:EPSG:4326\" }\n }\n}<\/code><\/pre>\n$polygon<\/h4>\n Der $polygon<\/code> Operator kann verwendet werden, um ein Polygon f\u00fcr eine GeoJSON $geoWithin<\/code> Abfrage auf Legacy-Koordinatenpaare anzugeben. Diese Abfrage gibt dann Paare zur\u00fcck, die innerhalb der Grenzen des Polygons liegen. $polygon<\/code> wird jedoch keine GeoJSON-Objekte abfragen. Um ein Polygon zu definieren, musst du ein Array von Koordinatenpunkten wie folgt angeben:<\/p>\n{\n : {\n $geoWithin: {\n $polygon: [ [ <x1> , <y1> ], [ <x2> , <y2> ], [ <x3> , <y3> ], ... ]\n }\n }\n}<\/code><\/pre>\nHier ist der letzte Punkt implizit mit dem ersten verbunden. Du kannst so viele Punkte oder Seiten angeben, wie du m\u00f6chtest.<\/p>\n
Die folgende Abfrage gibt zum Beispiel alle Dokumente zur\u00fcck, deren Koordinaten innerhalb des Polygons liegen, das durch [0,0], [1,5] und [3,3] definiert ist:<\/p>\n
db.places.find(\n {\n loc: {\n $geoWithin: { $polygon: [ [ 0 , 0 ], [ 1 , 5 ], [ 3 , 3 ] ] }\n }\n }\n)<\/code><\/pre>\n$geoWithin<\/h4>\n Dieser Operator kann verwendet werden, um Dokumente mit Geodaten auszuw\u00e4hlen, die vollst\u00e4ndig in einem bestimmten Shape enthalten sind. Die angegebene Form kann entweder ein GeoJSON-Multipolygon, ein GeoJSON-Polygon (entweder mit mehreren Ringen oder mit einem Ring) oder eine Form sein, die durch Legacy-Koordinatenpaare definiert werden kann.<\/p>\n
Der $geoWithin<\/code> Operator nutzt den $geometry<\/code> Operator, um das GeoJSON Objekt zu erw\u00e4hnen.<\/p>\nUm GeoJSON-Multipolygone oder Polygone \u00fcber das Standard-Koordinatenreferenzsystem (CRS) anzugeben, kannst du die folgende Syntax verwenden:<\/p>\n
{\n : {\n $geoWithin: {\n $geometry: {\n type: <\"Polygon\" or \"MultiPolygon\"> ,\n coordinates: [ <coordinates> ]\n }\n }\n }\n}<\/code><\/pre>\nBei $geoWithin<\/code> Abfragen, die GeoJSON-Geometrien mit Fl\u00e4chen gr\u00f6\u00dfer als eine einzelne Halbkugel erw\u00e4hnen, w\u00fcrde die Verwendung des Standard-CRS zu Abfragen f\u00fcr die komplement\u00e4ren Geometrien f\u00fchren.<\/p>\nUm ein einzelnes GeoJSON-Polygon mit einem benutzerdefinierten MongoDB-CRS zu erw\u00e4hnen, kannst du den unten genannten Prototyp in der $geometry<\/code> Expression verwenden:<\/p>\n{\n : {\n $geoWithin: {\n $geometry: {\n type: \"Polygon\" ,\n coordinates: [ <coordinates> ],\n crs: {\n type: \"name\",\n properties: { name: \"urn:x-mongodb:crs:strictwinding:EPSG:4326\" }\n }\n }\n }\n }\n}<\/code><\/pre>\nDas folgende Beispiel w\u00e4hlt alle Ortsdaten aus, die vollst\u00e4ndig innerhalb eines GeoJSON-Polygons liegen, wobei die Fl\u00e4che des Polygons kleiner als die Fl\u00e4che einer einzelnen Halbkugel ist:<\/p>\n
db.places.find(\n {\n loc: {\n $geoWithin: {\n $geometry: {\n type : \"Polygon\" ,\n coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ] ]\n }\n }\n }\n }\n)<\/code><\/pre>\n$box<\/h4>\n Mit $box<\/code> kannst du ein Rechteck f\u00fcr eine GeoJSON-Abfrage $geoWithin<\/code> angeben, um Dokumente zu finden, die sich innerhalb der Grenzen des Rechtecks befinden, entsprechend ihrer punktbasierten Standortdaten. Wenn du $geoWithin<\/code> mit $box<\/code> verwendest, erh\u00e4ltst du Dokumente, die auf den Koordinaten der Abfrage basieren. In diesem Szenario wird $geoWithin<\/code> keine GeoJSON Shapes abfragen.<\/p>\nUm den $box<\/code> Operator zu nutzen, musst du die obere rechte und untere linke Ecke des Rechtecks in einem Array-Objekt angeben:<\/p>\n