9 Arten von Mongodb-Operatoren, die Sie kennen müssen

In jedem Unternehmen sind Daten Ihr größtes Kapital. Durch die Analyse von Daten können Sie Entscheidungen zu Kundentrends und Verhaltensvorhersagen treffen. Dies steigert die Rentabilität des Unternehmens und die effektive Entscheidungsfindung.

Ohne Datenbanksoftware wäre eine einfache Aufgabe wie das Ermitteln des Durchschnitts aller Werte in einem System voller Datensätze mühsam. Glücklicherweise haben Datenbanken die Analyse von Daten mit Funktionen und Operatoren einfacher und schneller gemacht.

Dieser Artikel beleuchtet die Operatoren, die in der MongoDB-Datenbanksoftware verwendet werden.

Was sind MongoDB-Operatoren?

MongoDB ist eine NoSQL-Datenbanksoftware, die dokumentenorientierte Informationen verwaltet.

Eines der Hauptmerkmale von MongoDB ist seine Geschwindigkeit. Um Abfragen schneller zurückzugeben, kann MongoDB Operatoren verwenden, um bestimmte Funktionen auszuführen.

Operatoren sind spezielle Symbole, die Compilern helfen, mathematische oder logische Aufgaben auszuführen. MongoDB bietet verschiedene Arten von Operatoren für die Interaktion mit der Datenbank.

MongoDB-Operatortypen

Es gibt neun Arten von Operatoren, die jeweils nach ihrer Funktion benannt sind. Beispielsweise verwenden logische Operatoren logische Operationen. Um sie auszuführen, müssen Sie ein bestimmtes Schlüsselwort verwenden und der Syntax folgen. Sie sind jedoch ziemlich einfach zu befolgen!

Am Ende des Artikels werden Sie in der Lage sein, die Grundlagen jedes Operators und seiner Funktionen zu lernen.

Logische Operatoren

Logische Operatoren werden oft verwendet, um Daten basierend auf den gegebenen Bedingungen zu filtern. Sie ermöglichen auch die Bewertung vieler Bedingungen, auf die wir noch näher eingehen werden.

Nachfolgend finden Sie einige logische Operatoren, die Sie verwenden können:

$und

Eine „und“-Bedingung führt eine logische „und“-Operation auf einem Array aus zwei oder mehr Ausdrücken aus. Es wählt die Dokumente aus, bei denen alle Bedingungen der Ausdrücke erfüllt sind.

Dies ist die Standard-Syntax für den $and Ausdruck:

 { $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } Wenn wir beispielsweise Dokumente auswählen möchten, deren Preis 10 $ und die Menge weniger als 15 beträgt, Wir können die folgende Abfrage eingeben:

 db.inventory.find( { $and: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )

$oder

Eine „oder“-Bedingung führt eine logische „oder“-Operation auf einem Array von zwei oder mehr Ausdrücken aus. Es wählt die Dokumente aus, bei denen mindestens einer der Ausdrücke wahr ist.

Dies ist die Standard-Syntax für den $or Ausdruck:

 { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }.

Wenn wir beispielsweise Dokumente auswählen möchten, deren Preis 10 $ oder die Menge weniger als 15 beträgt, können wir die folgende Abfrage eingeben:

 db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )

Wir müssen den Ausdruck nicht auf zwei Kriterien beschränken – wir können weitere hinzufügen. Die folgende Abfrage wählt beispielsweise die Dokumente aus, bei denen der Preis 10 $ beträgt, die Menge unter 15 liegt oder das Etikett stationär ist:

 db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 }, { tag: stationary }] } )

Beim Ausführen dieser Klauseln führt MongoDB entweder einen Erfassungsscan oder einen Indexscan durch. Wenn alle Indizes die Klauseln unterstützen, verwendet MongoDB Indizes, um einen $or Ausdruck zu prüfen. Andernfalls wird stattdessen ein Sammlungsscan verwendet.

Wenn Sie jedoch die Kriterien im selben Feld testen möchten, sollten Sie den $in Operator anstelle des $or Operators verwenden. Wenn Sie beispielsweise eine Sammlung von Dokumenten wünschen, bei denen die Menge entweder 10 oder 20 beträgt, müssen Sie möglicherweise stattdessen die folgende $in Abfrage ausführen:

 db.inventory.find ( { quantity: { $in: [20, 50] } } )

Wir werden später mehr über den $in Operator behandeln.

$noch

Dieser Operator führt mithilfe eines oder mehrerer Ausdrücke eine logische „nor“-Operation auf einem Array aus. Als nächstes wählt es die Dokumente aus, die die Abfrageausdrücke nicht erfüllen. Einfacher ausgedrückt macht es das Gegenteil der $or Bedingung.

Dies ist die allgemeine Syntax:

 { $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }

Betrachten wir die folgende Abfrage:

 db.inventory.find( { $nor: [ { price: 3.99 }, { sale: true } ] } )

Diese Abfrage wählt die Dokumente aus, die Folgendes enthalten:

• ein Preisfeldwert ungleich 3,99 $ und ein Verkaufswert ungleich wahr; oder
• ein Preisfeldwert ungleich 3,99 $ und ein leeres oder fehlendes Verkaufsfeld; oder
• kein Preisfeld und ein Verkaufsfeld ungleich wahr; oder
• Weder das Preisfeld noch das Verkaufsfeld sind ausgefüllt oder vorhanden.

$nicht

Dieser Operator führt eine logische „Nicht“-Operation auf einem Array für den angegebenen Ausdruck aus. Anschließend werden die Dokumente ausgewählt, die nicht mit den Abfrageausdrücken übereinstimmen. Dies schließt die Dokumente ein, die das Feld nicht enthalten.

Dies ist die allgemeine Syntax:

 { field: { $not: { <operator-expression> } } }

Nehmen Sie zum Beispiel die folgende Abfrage:

 db.inventory.find( { price: { $not: { $lt: 3.99 } } } )

Diese Abfrage würde die Dokumente auswählen, die Folgendes enthalten:

• ein Preisfeld, dessen Wert größer oder gleich 3,99 $ ist; und
• ein Preisfeld ist nicht ausgefüllt oder existiert nicht.

Vergleichsoperatoren

Vergleichsoperatoren können verwendet werden, um Werte in einem oder mehreren Dokumenten zu vergleichen.

Unten ist ein Beispielcode einer einfachen Bestandserfassung für ein Supermarktgeschäft:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] }, { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] }, { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }, { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

Wir verwenden dieses Beispiel, während wir als Nächstes jeden Vergleichsoperator im Detail beschreiben.

Gleich ($eq)

Dieser Operator passt Werte an, die gleich dem angegebenen Wert sind:

 { <field>: { $eq: <value> } }

Wenn wir beispielsweise ein bestimmtes Dokument aus der Bestandssammlung mit dem genauen Mengenwert „20“ abrufen möchten, würden wir den folgenden Befehl eingeben:

 db.inventory.find( { qty: { $eq: 20 } } )

Die Abfrage würde Folgendes zurückgeben:

 { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Größer als ($gt)

Dieser Operator passt, wenn die Werte größer als der angegebene Wert sind:

 { field: { $gt: value } }

In diesem Beispiel rufen wir die Dokumente ab, deren Menge größer als 15 ist:

 db.inventory.find({"qty": { $gt: 15}})

Die Abfrage würde Folgendes zurückgeben:

 { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Weniger als ($lt)

Dieser Operator passt, wenn Werte kleiner als der angegebene Wert sind:

 { field: { $lt: value } }

Lassen Sie uns die Dokumente mit einer Menge von weniger als 25 finden:

 db.inventory.find({"qty": { $lt: 25}})

Die Abfrage würde Folgendes zurückgeben:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Größer oder gleich ($gte)

Dieser Operator passt, wenn die Werte größer oder gleich dem angegebenen Wert sind:

 { field: { $gte: value } }

In diesem Beispiel rufen wir die Dokumente ab, bei denen die Menge größer oder gleich 25 ist:

 db.inventory.find({"qty": { $gte: 25}})

Diese Abfrage würde Folgendes zurückgeben:

 { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }

Kleiner oder gleich ($lte)

Dieser Operator passt nur, wenn die Werte kleiner oder gleich dem angegebenen Wert sind:

 { field: { $lte: value } }

Lassen Sie uns die Dokumente mit einer Menge kleiner oder gleich 25 finden.

 db.inventory.find({"qty": { $lte: 25}})

Wir können davon ausgehen, dass diese Abfrage Folgendes zurückgibt:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Ein ($ein)

Dieser Operator gibt die Dokumente zurück, die den angegebenen Werten entsprechen:

 { field: { $in: [<value1>, <value2>, ... <valueN> ] } }

Der Wert eines Felds ist gleich einem beliebigen Wert im angegebenen Array. Um beispielsweise die Dokumente mit den Werten „30“ und „15“ in der Bestandssammlung abzurufen, gehen Sie wie folgt vor:

 db.collection.find({ "qty": { $in: [30, 15]}})

Die Ausgabe wäre:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }

Nicht in ($nin)

Dieser Operator gibt die Dokumente zurück, die nicht mit den angegebenen Werten übereinstimmen. Hier ist die grundlegende Syntax des $nin Operators:

 { field: { $nin: [ <value1>, <value2> ... <valueN> ]

$nin wählt die Dokumente aus, in denen:

• der Feldwert befindet sich nicht im angegebenen Array; oder
• das Feld existiert nicht.

Wenn das Feld Arrays enthält, werden Arrays ausgewählt, in denen kein im Wertabschnitt angegebenes Element vorhanden ist. Beispielsweise möchten wir die Dokumente auswählen, bei denen die Menge weder 20 noch 15 beträgt.

Darüber hinaus werden auch Dokumente abgeglichen, die kein Mengenfeld haben:

 db.collection.find({ "qty": { $nin: [ 20, 15 ]}}, {_id: 0})

Die Ausgabe wäre:

 { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

Ungleich ($ne)

Der $ne Operator gibt die Dokumente zurück, bei denen der angegebene Wert nicht gleich ist:

 { $ne: value } }

Angenommen, wir möchten alle Dokumente auswählen, deren Anzahl nicht gleich 20 ist:

 db.inventory.find( { qty: { $ne: 20 } } )

Die Ausgabe wäre:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

Aus der obigen Ausgabe können wir sehen, dass die Abfrage Dokumente auswählt, die kein Mengenfeld haben.

Elementoperatoren

Die Elementabfrageoperatoren können Dokumente anhand der Felder des Dokuments identifizieren. Elementoperatoren bestehen aus $exist und $type .

$existiert

Dieser Operator stimmt mit Dokumenten überein, die ein bestimmtes Feld haben. Dieser Operator hat einen booleschen Wert, der entweder true oder false sein kann.

Wenn es auf true festgelegt ist, stimmt es mit den Dokumenten überein, die dieses Feld enthalten, einschließlich Dokumenten, bei denen der Feldwert null ist. Wenn <boolean> false ist, gibt die Abfrage nur die Dokumente zurück, die das Feld nicht enthalten.

Hier ist die Standard-Syntax:

 { field: { $exists: <boolean> } }

Nehmen wir ein Beispiel, in dem wir Sammlungsdaten für ein Array namens „bagofmarbles“ haben, in dem jede Tasche Murmeln in verschiedenen Farben enthält:

 { red: 5, green: 5, blue: null } { red: 3, green: null, blue: 8 } { red: null, green: 3, blue: 9 } { red: 1, green: 2, blue: 3 } { red: 2, blue: 5 } { red: 3, green: 2 } { red: 4 } { green: 2, blue: 4 } { green: 2 } { blue: 6 }

Angenommen, wir möchten eine Abfrage, die nur die Beutel zurückgibt, in denen die roten Murmeln vorhanden sind. Das bedeutet, dass wir den booleschen Wert als true eingeben müssten. Lass uns einen Blick darauf werfen:

 db.bagofmarbles.find( { red: { $exists: true } } )

Die Ergebnisse würden aus den Dokumenten bestehen, die das Feld „rot“ enthalten, selbst wenn der Wert null wäre. Es würde jedoch nicht aus den Dokumenten bestehen, bei denen das Feld „rot“ nicht einmal vorhanden wäre:

 { red: 5, green: 5, blue: null } { red: 3, green: null, blue: 8 } { red: null, green: 3, blue: 9 } { red: 1, green: 2, blue: 3 } { red: 2, blue: 5 } { red: 3, green: 2 } { red: 4 }

Wenn wir nur die Taschen haben wollten, in denen rote Murmeln nicht einmal als Feld existieren, können wir die folgende Abfrage eingeben:

 db.bagofmarbles.find( { red: { $exists: false} }

Die Ergebnisse würden aus den Dokumenten bestehen, die das Feld „rot“ nicht enthalten:

 { green: 2, blue: 4 } { green: 2 } { blue: 6 }

$typ

Dieser Operator gleicht Dokumente gemäß dem angegebenen Feldtyp ab. Dies ist nützlich, wenn Sie stark unstrukturierte Daten haben oder wenn die Datentypen nicht vorhersehbar sind. Diese Feldtypen sind spezifizierte BSON-Typen und können entweder durch Typnummer oder Alias ​​definiert werden.

Dies ist die allgemeine Syntax für $type :

 { field: { $type: <BSON type> } }

Angenommen, wir haben ein Adressbuch mit den folgenden Dokumenten:

 db={ addressBook: [ { "_id": 1, address: "2100 Jupiter Spot", zipCode: "9036325" }, { "_id": 2, address: "25 Moon Place", zipCode: 26237 }, { "_id": 3, address: "2324 Neptune Ring", zipCode: NumberLong(77622222) }, { "_id": 4, address: "33 Saturns Moon", zipCode: NumberInt(117) }, { "_id": 5, address: "1044 Venus Lane", zipCode: [ "99883637232", "73488976234" ] } ] }

Bei Betrachtung der obigen Dokumente hat die Postleitzahl unterschiedliche Datentypen. Dazu gehören Long-, Double-, Integer- und String-Werte.

Wenn wir nur die Dokumente wollen, die einen bestimmten Datentyp als Postleitzahl haben – nehmen wir für diese Instanz eine Zeichenfolge –, müssten wir die folgende Abfrage in den Compiler eingeben:

 db.addressBook.find({ "zipCode": { $type: "string" } })

Dies würde die folgenden Dokumente zurückgeben:

 [ { "_id": 1, "address": "2100 Jupiter Spot", "zipCode": "9036325" }, { "_id": 5, "address": "1044 Venus Lane", "zipCode": [ "99883637232", "73488976234" ] } ]

Zusätzlich gibt es einen „number“-Typ, der alle Long-, Integer- oder Double-Werte als Array enthält, das ein Element der angegebenen Typen enthält:

 db.addressBook.find( { "zipCode" : { $type : "number" } } )

Ausgabe:

 [ { "_id": 2, address: "25 Moon Place", zipCode: 26237 }, { "_id": 3, address: "2324 Neptune Ring", zipCode: NumberLong(77622222) }, { "_id": 4, address: "33 Saturns Moon", zipCode: NumberInt(117) } ]

Wenn die Dokumente einen Array-Feldtyp haben, gibt der $type Operator die Dokumente zurück, in denen mindestens ein Array-Element mit dem an den Operator übergebenen Typ übereinstimmt.

Array-Operatoren

MongoDB besteht auch aus Array-Operatoren, um Dokumente abzufragen, die Arrays enthalten.

Es gibt drei primäre Operatoren: $all , $elemMatch und $size . Wir werden jeden im Folgenden im Detail besprechen.

$alle

Der $all Operator wählt die Dokumente aus, in denen der Wert eines Felds ein Array ist, das die angegebenen Elemente enthält:

 { : { $all: [ <value1> , <value2> ... ] } }

Nehmen wir zum Beispiel an, wir haben eine Sammlung von Dokumenten für ein Bekleidungsgeschäft mit den folgenden unter Inventar.

 { _id: ObjectId("5234cc89687ea597eabee675"), code: "shirt", tags: [ "sale", "shirt", "button", "y2k", "casual" ], qty: [ { size: "S", num: 10, color: "blue" }, { size: "M", num: 45, color: "blue" }, { size: "L", num: 100, color: "green" } ] }, { _id: ObjectId("5234cc8a687ea597eabee676"), code: "pant", tags: [ "y2k", "trendy", "shine" ], qty: [ { size: "6", num: 100, color: "green" }, { size: "6", num: 50, color: "blue" }, { size: "8", num: 100, color: "brown" } ] }, { _id: ObjectId("5234ccb7687ea597eabee677"), code: "pant2", tags: [ "trendy", "shine" ], qty: [ { size: "S", num: 10, color: "blue" }, { size: "M", num: 100, color: "blue" }, { size: "L", num: 100, color: "green" } ] }, { _id: ObjectId("52350353b2eff1353b349de9"), code: "shirt2", tags: [ "y2k", "trendy" ], qty: [ { size: "M", num: 100, color: "green" } ] }

Wir möchten alle Dokumente (in diesem Fall die Kleidung) aus dem Inventar abrufen, die mit den Tags „trendy“ und „y2k“ verknüpft sind. Die folgende Abfrage verwendet den $all Operator, wobei der Wert des Tags-Felds ein Array ist, dessen Elemente „y2k“ und „trendy“ enthalten:

 db.inventory.find( { tags: { $all: [ "y2k", "trendy" ] } } )

Die obige Abfrage gibt Folgendes zurück:

 { _id: ObjectId("5234cc8a687ea597eabee676"), code: "pant", tags: [ "y2k", "trendy", "shine" ], qty: [ { size: "6", num: 100, color: "green" }, { size: "6", num: 50, color: "blue" }, { size: "8", num: 100, color: "brown" } ] } { _id: ObjectId("52350353b2eff1353b349de9"), code: "shirt2", tags: [ "y2k", "trendy" ], qty: [ { size: "M", num: 100, color: "green" } ] }

Aus dem obigen Beispiel sehen wir auch, dass der $all Operator einfach dieselbe Funktion ausführt wie die $and Operation.

Alternativ könnten wir die folgende Abfrage verwenden, die eine ähnliche Ausgabe wie die obige liefern würde:

 db.collection.find({ $and: [ { tags: "y2k" }, { tags: "trendy" } ] })

$elemMatch

Der $elemMatch Operator gleicht Dokumente ab, die ein Array-Feld mit mindestens einem Element enthalten, das allen angegebenen Abfragekriterien entspricht:

 { : { $elemMatch: { <query1>, <query2>, ... } } }

Wir können zwar Vergleichsoperatoren wie $lte und $gte , aber wenn wir nur eine einzige Abfragebedingung in $elemMatch elemMatch angeben und die $not not- oder $ne Operatoren nicht verwenden, kann die Verwendung $elemMatch weggelassen werden, da dies im Wesentlichen eine Leistung erbringen würde die gleiche Funktion.

Es gibt ein paar weitere Dinge, die Sie bei der Verwendung dieses Operators beachten sollten, hauptsächlich:

• Sie können keinen $where Ausdruck in einer $elemMatch Operation angeben.
• Sie können keinen $text Abfrageausdruck in einer $elemMatch Operation angeben.

Zum Beispiel haben wir die folgenden Dokumente in der Sammlung der Schülerergebnisse:

 { _id: 1, results: [ 92, 89, 98 ] } { _id: 2, results: [ 85, 99, 99 ] }

Die folgende Abfrage stimmt nur mit den Dokumenten überein, bei denen das Ergebnisarray mindestens ein Element enthält, das sowohl größer als oder gleich 90 als auch kleiner als 95 ist:

 db.studentresults.find( { results: { $elemMatch: { $gte: 90, $lt: 95 } } })

Unsere Abfrage gibt das folgende Dokument zurück, da das Element 92 sowohl größer als oder gleich 90 als auch kleiner als 95 ist:

 { "_id" : 1, "results" :[ 92, 89, 98 ] }

$größe

Der $size Operator gibt die Dokumente zurück, bei denen die Größe des Arrays mit der im Argument angegebenen Anzahl von Elementen übereinstimmt:

 { field: { $size: value } }

Hier ist ein Beispiel:

 db.collection.find( { field: { $size: 2 } });

Dies würde alle Dokumente in der angegebenen Sammlung zurückgeben, bei denen das Feld ein Array mit 2 Elementen ist: { field: [ orange, apple] } und { field: [ blue, red] } , aber nicht { field: blue} oder { field: [ raspberry, lemon, grapefruit ] } .

Während wir jedoch den spezifischen Wert als Größe eingeben können, können wir keine Wertebereiche als Größe angeben.

Geodaten-Operatoren

Mit MongoDB können Sie Geodaten in Form von GeoJSON-Typen speichern. GeoJSON ist ein offenes Standardformat, das auf der JavaScript-Objektnotation basiert und geografische Merkmale darstellen und nicht-räumliche Attribute unterstützen kann. Es gibt zwei Arten von Geooperatoren, über die wir in diesem Artikel sprechen werden: Geometriespezifizierer und Abfrageselektoren.

$geometrie

Dieser Operator erwähnt die GeoJSON-Geometrie zur Verwendung mit den folgenden Geodaten-Abfrageoperatoren: $geoIntersects , $geoWithin , $nearSphere und $near . $geometry nutzt EPSG:4326 als Standard-Koordinatenreferenzsystem (CRS).

Um GeoJSON-Objekte mit dem Standard-CRS zu erwähnen, können Sie das folgende Snippet für $geometry nutzen:

 $geometry: { type: "<GeoJSON object type>", coordinates: [ <coordinates> ] }

Um ein Single-Ringed-GeoJSON-Polygon mit einem maßgeschneiderten MongoDB-CRS zu erwähnen, können Sie das folgende Snippet verwenden (Sie können dies nur für $geoWithin und $geoIntersects ):

 $geometry: { type: "Polygon", coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } }

$Polygon

Der $polygon Operator kann verwendet werden, um ein Polygon für eine Geodaten- $geoWithin Abfrage für Legacy-Koordinatenpaare anzugeben. Diese Abfrage gibt dann Paare zurück, die innerhalb der Grenzen des Polygons liegen. $polygon wird jedoch keine GeoJSON-Objekte abfragen. Um ein Polygon zu definieren, müssen Sie wie folgt ein Array von Koordinatenpunkten angeben:

 { : { $geoWithin: { $polygon: [ [ <x1> , <y1> ], [ <x2> , <y2> ], [ <x3> , <y3> ], ... ] } } }

Dabei ist der letzte Punkt implizit mit dem ersten verbunden. Sie können so viele Punkte oder Seiten erwähnen, wie Sie möchten.

Die folgende Abfrage gibt beispielsweise alle Dokumente zurück, deren Koordinaten innerhalb des durch [0,0], [1,5] und [3,3] definierten Polygons liegen:

 db.places.find( { loc: { $geoWithin: { $polygon: [ [ 0 , 0 ], [ 1 , 5 ], [ 3 , 3 ] ] } } } )

$geoWithin

Dieser Operator kann verwendet werden, um Dokumente mit Geodaten auszuwählen, die vollständig in einer bestimmten Form 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.

Der $geoWithin Operator nutzt den $geometry Operator, um das GeoJSON-Objekt zu erwähnen.

Um die GeoJSON-Multipolygone oder -Polygone über das standardmäßige Koordinatenreferenzsystem (CRS) zu erwähnen, können Sie die unten erwähnte Syntax verwenden:

 { : { $geoWithin: { $geometry: { type: <"Polygon" or "MultiPolygon"> , coordinates: [ <coordinates> ] } } } }

Bei $geoWithin Abfragen, die die GeoJSON-Geometrien mit Bereichen erwähnen, die größer als eine einzelne Halbkugel sind, würde die Verwendung des Standard-CRS zu Abfragen für die komplementären Geometrien führen.

Um ein einringiges GeoJSON-Polygon mit einem benutzerdefinierten MongoDB-CRS zu erwähnen, können Sie den unten erwähnten Prototyp im $geometry Ausdruck nutzen:

 { : { $geoWithin: { $geometry: { type: "Polygon" , coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } } } } }

Das folgende Beispiel wählt alle Lokdaten aus, die vollständig in einem GeoJSON-Polygon vorhanden sind, wobei die Fläche des Polygons kleiner ist als die Fläche einer einzelnen Hemisphäre:

 db.places.find( { loc: { $geoWithin: { $geometry: { type : "Polygon" , coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ] ] } } } } )

$box

Sie können $box verwenden, um ein Rechteck für eine geospatiale $geoWithin Abfrage anzugeben, um Dokumente bereitzustellen, die sich gemäß ihren punktbasierten Standortdaten innerhalb der Grenzen des Rechtecks ​​befinden. Wenn Sie $geoWithin mit $box , erhalten Sie Dokumente basierend auf Abfragekoordinaten. In diesem Szenario $geoWithin keine GeoJSON-Shapes ab.

Um den $box Operator zu nutzen, müssen Sie die obere rechte und die untere linke Ecke des Rechtecks ​​in einem Array-Objekt erwähnen:

 { <location field> : { $geoWithin: { $box: [ [ <bottom left coordinates> ], [ <upper right coordinates> ] ] } } }

Die oben erwähnte Abfrage berechnet den Abstand unter Verwendung planarer (flacher) Geometrie. Die folgende Abfrage gibt alle Dokumente zurück, die sich in der Box befinden und die Punkte bei: [0,0], [0,30], [30,0], [30,30] haben:

 db.places.find ( { loc: { $geoWithin: { $box: [ [ 0,0 ], [ 30,30 ] ] } } } )

$nearSphere

Sie können $nearSphere verwenden, um einen Punkt anzugeben, für den eine Geodatenabfrage die Dokumente vom nächsten zum am weitesten entfernten zurückgibt.

MongoDB verwendet sphärische Geometrie, um die Entfernungen für $nearSphere zu berechnen. Es wird ein Geodatenindex wie folgt benötigt:

1. 2D-Index für Positionsdaten, die als Legacy-Koordinatenpaare beschrieben werden. Um einen 2D-Index für GeoJSON-Punkte zu nutzen, müssen Sie den Index im Koordinatenfeld des GeoJSON-Objekts generieren.
2. 2dsphere-Index für Standortdaten, die als GeoJSON-Punkte beschrieben werden.

Um einen GeoJSON-Punkt zu erwähnen, können Sie die folgende Syntax nutzen:

 { $nearSphere: { $geometry: { type : "Point", coordinates : [ <longitude>, <latitude> ] }, $minDistance: <distance in meters>, $maxDistance: <distance in meters> } }

Hier sind $minDistance und $maxDistance optional. $minDistance kann die Ergebnisse auf die Dokumente beschränken, die mindestens den angegebenen Abstand vom Mittelpunkt haben. Sie können $maxDistance für beide Indizes verwenden.

Stellen Sie sich nun eine Sammlung von „Orten“ vor, die aus Dokumenten mit einem Ortsfeld mit einem 2dsphere-Index besteht. Das folgende Beispiel würde die Punkte zurückgeben, deren Position mindestens 2.000 Meter und höchstens 6.000 Meter von dem ausgewählten Punkt entfernt ist, sortiert vom nächsten zum am weitesten entfernten:

 db.places.find( { location: { $nearSphere: { $geometry: { type : "Point", coordinates : [ -43.9532, 50.32 ] }, $minDistance: 2000, $maxDistance: 6000 } } } )

$geoIntersects

Mit dem $geoIntersects Operator können Sie Dokumente auswählen, deren Geodaten sich mit einem bestimmten GeoJSON-Objekt überschneiden (dh wo die Konvergenz des angegebenen Objekts und der Daten nicht leer ist). Es nutzt den $geometry Operator, um das GeoJSON-Objekt anzugeben.

Um GeoJSON-Multipolygone oder -Polygone über das Standardkoordinatenreferenzsystem (CRS) zu erwähnen, können Sie die folgende Syntax verwenden:

 { <location field>: { $geoIntersects: { $geometry: { type: "<GeoJSON object type>" , coordinates: [ <coordinates> ] } } } }

Die folgende Instanz verwendet $geoIntersects , um alle Positionsdaten auszuwählen, die sich mit dem durch das Koordinaten-Array beschriebenen Polygon schneiden:

 db.places.find( { loc: { $geoIntersects: { $geometry: { type: "Polygon" , coordinates: [ [ [ 0, 0 ], [ 2, 6 ], [ 4, 1 ], [ 0, 0 ] ] ] } } } } )

$center

Der $center Operator erwähnt einen Kreis für eine $geoWithin Abfrage, die Legacy-Koordinatenpaare zurückgibt, die sich innerhalb der Grenzen des Kreises befinden.

$center gibt keine GeoJSON-Objekte zurück. Um den $center Operator zu nutzen, müssen Sie ein Array angeben, das Folgendes enthält:

1. Der Radius des Kreises, gemessen in den vom Koordinatensystem verwendeten Einheiten.
2. Die Gitterkoordinaten des Mittelpunkts des Kreises.

 { <location field> : { $geoWithin: { $center: [ [ <x> , <y> ] , <radius> ] } } }

Das unten erwähnte Beispiel gibt alle Dokumente zurück, die Koordinaten haben, die innerhalb des Kreises gefunden werden können, der auf [2,3] zentriert ist und einen Radius von 40 hat:

 db.places.find( { loc: { $geoWithin: { $center: [ [2, 3], 40 ] } } } )

Projektionsoperatoren

Sie können Projektionsoperatoren verwenden, um die von einer Operation zurückgegebenen Felder zu erwähnen. MongoDB-Projektionsoperatoren ermöglichen die Verwendung der find() Funktion mit Datenfilterargumenten. Dies hilft Benutzern, nur die erforderlichen Datenfelder aus einem Dokument zu extrahieren. So können Sie transparente und präzise Daten projizieren, ohne die Gesamtleistung der Datenbank zu beeinträchtigen.

$elemMatch (Projektion)

Der $elemMatch Operator ist dafür verantwortlich, den Inhalt eines Felds aus den Abfrageergebnissen so zu begrenzen, dass er nur das erste Element enthält, das der $elemMatch Bedingung entspricht.

Hier sind ein paar Dinge, die Sie beachten müssen, bevor Sie $elemMatch :

• Ab MongoDB 4.4 gibt die $elemMatch Projektion eines vorhandenen Felds unabhängig von der Reihenfolge der Felder im Dokument das Feld nach Einbeziehung anderer vorhandener Felder zurück.
• Sowohl der $elemMatch als auch der $ -Operator stellen das erste übereinstimmende Element aus einem Array basierend auf einer angegebenen Bedingung dar. Der $ -Operator projiziert das erste übereinstimmende Array-Element aus jedem Dokument in einer Sammlung basierend auf einer Bedingung aus der Abfrageanweisung, während der $elemMatch Projektionsoperator ein explizites Bedingungsargument akzeptiert. Auf diese Weise können Sie basierend auf einer Bedingung projizieren, die in der Abfrage nicht vorhanden ist, oder wenn Sie basierend auf verschiedenen Feldern in den eingebetteten Dokumenten des Arrays projizieren müssen.

Sie sollten sich auch der folgenden Einschränkungen bewusst sein, bevor Sie den $elemMatch Operator für Ihre Daten verwenden:

• Sie können einen $text Abfrageausdruck nicht innerhalb eines $elemMatch Operators erwähnen.
• db.collection.find() Operationen für Ansichten unterstützen den $elemMatch Projektionsoperator nicht.

Das folgende Beispiel für den Projektionsoperator $elemMatch geht von einer Sammlung schools mit den folgenden Dokumenten aus:

 { _id: 1, zipcode: "63108", students: [ { name: "mark", school: 102, age: 9 }, { name: "geoff", school: 101, age: 13 }, { name: "frank", school: 104, age: 12 } ] } { _id: 2, zipcode: "63110", students: [ { name: "harry", school: 103, age: 14 }, { name: "george", school: 103, age: 7 }, ] } { _id: 3, zipcode: "63108", students: [ { name: "harry", school: 103, age: 14 }, { name: "george", school: 103, age: 7 }, ] } { _id: 4, zipcode: "63110", students: [ { name: "jim", school: 103, age: 9 }, { name: "michael", school: 103, age: 12 }, ] }

In diesem Fall fragt die find() Operation alle Dokumente ab, bei denen der Wert des Postleitzahlenfelds 63110 ist. Die $elemMatch Projektion würde nur das erste übereinstimmende Element des students -Arrays zurückgeben, bei dem das school einen Wert von 103 hat:

 db.schools.find( { zipcode: "63110" }, { students: { $elemMatch: { school: 103 } } } ) This is what the result would look like: { "_id" : 2, "students" : [ { "name" : "harry", "school" : 103, "age" : 14 } ] } { "_id" : 4, "students" : [ { "name" : "jim", "school" : 103, "age" : 9 } ] }

$slice (Projektion)

Der Projektionsoperator $slice kann verwendet werden, um die Anzahl der Elemente in einem Array anzugeben, die im Abfrageergebnis zurückgegeben werden sollen:

 db.collection.find( <query> , { <arrayField> : { $slice: <number> } } );

Man kann es auch so ausdrücken:

 db.collection.find( <query> , { <arrayField> : { $slice: [ <number> , <number> ] } } );

Um dasselbe zu demonstrieren, können Sie eine Beispielsammlung von Tweets mit den folgenden Dokumenten erstellen:

 db.posts.insertMany([ { _id: 1, title: "Nuts are not blueberries.", comments: [ { comment: "0. true" }, { comment: "1. blueberries aren't nuts."} ] }, { _id: 2, title: "Coffee please.", comments: [ { comment: "0. Indubitably" }, { comment: "1. Cuppa tea please" }, { comment: "2. frappucino" }, { comment: "3. Mocha latte" }, { comment: "4. whatever" } ] } ])

Die folgende Operation würde den $slice Projektionsoperator für das tweets-Array verwenden, um das Array mit seinen ersten beiden Elementen zurückzugeben. Wenn ein Array weniger als zwei Elemente enthält, werden alle Elemente im Array zurückgegeben:

 db.posts.find( {}, { comments: { $slice: 2 } } )

Diese Operation würde die folgenden Dokumente zurückgeben:

 { "_id" : 1, "title" : "Nuts are not blueberries.", "comments" : [ { "comment" : "0. true" }, { "comment" : "1. blueberries aren't nuts." } ] } { "_id" : 2, "title" : "Coffee please.", "comments" : [ { "comment" : "0. Indubitably" }, { "comment" : "1. Cuppa tea please" } ] }

$ (Projektion)

Der Positionsoperator $ begrenzt den Inhalt eines Arrays, um das erste Element zurückzugeben, das der Abfragebedingung dieses Arrays entspricht. Sie können $ im Projektionsdokument der find() Methode oder der findOne() Methode verwenden, wenn Sie nur ein bestimmtes Array-Element in ausgewählten Dokumenten benötigen.

So sieht die Syntax für den $ -Operator aus:

 db.collection.find( { <array>: <condition> ... }, { "<array>.$": 1 } ) db.collection.find( { <array.field>: <condition> ...}, { "<array>.$": 1 } )

In diesem Beispiel besteht die students aus den folgenden Dokumenten:

 { "_id" : 1, "semester" : 2, "grades" : [ 75, 67, 93 ] } { "_id" : 2, "semester" : 2, "grades" : [ 60, 68, 72 ] } { "_id" : 3, "semester" : 2, "grades" : [ 95, 82, 67 ] } { "_id" : 4, "semester" : 3, "grades" : [ 89, 95, 70 ] } { "_id" : 5, "semester" : 3, "grades" : [ 68, 98, 82 ] } { "_id" : 6, "semester" : 3, "grades" : [ 65, 70, 76 ] }

In der folgenden Abfrage gibt die Projektion { "grades.$": 1 } nur das erste Element größer oder gleich 89 für das Feld " grades " zurück:

 db.students.find( { semester: 2, grades: { $gte: 89 } }, { "grades.$": 1 } )

Dieser Vorgang gibt die folgenden Dokumente zurück:

 {"_id": 3, "grades": [95] }

Bewertungsoperatoren

Sie können MongoDB-Evaluierungsoperatoren nutzen, um die gesamte Datenstruktur oder einzelne Felder in einem Dokument zu messen.

Sehen wir uns einige gängige MongoDB-Evaluierungsoperatoren an.

$mod

Sie können diesen Operator verwenden, um Dokumente abzugleichen, bei denen der Wert eines bestimmten Felds gleich dem Rest ist, nachdem er durch einen bestimmten Wert dividiert wurde:

 { field: { $mod: [ divisor, remainder ] } }

Angenommen, Sie haben in Ihrem Ausstellungsraum eine Tabelle mit Autos verschiedener Marken, die Sie besitzen. Die folgende Abfrage würde Ihnen alle Automarken liefern, deren Bestandsnummern ein Vielfaches von 250 sind.

 db.cars.find ( { qty: { $mod: [ 250,0 ] } } )

$jsonSchema

Mit dem $jsonSchema können Sie die Dokumente abgleichen, die mit dem angegebenen JSON-Schema übereinstimmen. Die MongoDB-Implementierung des JSON-Schemas umfasst das Hinzufügen des bsonType Schlüsselworts, mit dem Sie alle BSON-Typen innerhalb des $jsonSchema Operators verwenden können.

bsonType kann die gleichen String-Aliase akzeptieren, die Sie für den type verwenden würden. So würde die Syntax von $jsonSchema aussehen:

 { $jsonSchema: <JSON Schema object> }

Hier wird das JSON-Schema-Objekt basierend auf dem Entwurf 4 des JSON-Schema-Standards formatiert:

 { <keyword1>: <value1>, ... }

Hier ist ein Beispiel, um zu demonstrieren, wie $jsonSchema funktioniert:

 { $jsonSchema: { required: [ "name", "major", "gpa", "address" ], properties: { name: { bsonType: "string", description: "must be a string and is required" }, address: { bsonType: "object", required: [ "zipcode" ], properties: { "street": { bsonType: "string" }, "zipcode": { bsonType: "string" } } } } } }

Sie können $jsonSchema auch in einem Dokumentvalidierer verwenden, um das angegebene Schema bei Aktualisierungs- und Einfügevorgängen zu erzwingen:

 db.createCollection(<collection> , { validator: { $jsonSchema: <schema> } } ) db.runCommand( { collMod: <collection>, validator:{ $jsonSchema: <schema> } } )

Denken Sie daran, dass einige Dinge vom $jsonSchema Operator nicht unterstützt werden:

1. Der ganzzahlige Typ. Sie müssen den BSON-Typ long oder int mit dem Schlüsselwort bsonType nutzen.
2. Unbekannte Schlüsselwörter.
3. Verknüpfen von Eigenschaften und Hypermedia des JSON-Schemas, zusammen mit der Verwendung von JSON-Referenzen und JSON-Zeigern.

$text

Der $text Operator würde nach einem Text innerhalb des Inhalts des angegebenen Felds suchen, indiziert mit einem Textindex:

 { $text: { $search: <string>, $language: <string>, $caseSensitive: <boolean>, $diacriticSensitive: <boolean> } }

In diesem Fall durchsucht das folgende Code-Snippet die Tabelle, um alle Autos herauszufiltern, die den Text „Porsche“ enthalten:

 db.cars.find( { $text: { $search: "Porsche" } } )

$regex

Der $regex Operator bietet Möglichkeiten für reguläre Ausdrücke, um übereinstimmende Zeichenfolgen in Abfragen zu mustern. MongoDB nutzt reguläre Ausdrücke, die mit Perl kompatibel sind:

 {<field> : /pattern/ <options>}

Das folgende Beispiel würde helfen, alle Autos herauszufiltern, die die Zeichenfolge „$78900“ enthalten:

 db.cars.find( { price: { $regex: /$78900/ } } )

$expr

Mit dem $expr Operator können Sie Aggregationsausdrücke innerhalb der Abfragesprache nutzen:

 { $expr: { <expression> } }

Sie können $expr auch verwenden, um Abfrageausdrücke zu erstellen, die Felder aus demselben Dokument in einer $match Phase vergleichen. If the $match stage happens to be the part of a $lookup stage, $expr can compare fields with the help of let variables.

$where

You can leverage the $where operator to either pass a string containing a full JavaScript function or a JavaScript expression to the query system. The $where operator provides greater flexibility but needs the database to process the JavaScript function or expression for every document in the collection. You can reference this document in the JavaScript function or expression by using either obj or this .

Here's an example of the syntax:

 { $where: <string|JavaScript Code> }

There are a few key considerations to keep in mind before we dive into an example while using the $where operator:

• You should only use the $where query operator to top-level documents. The $where query operator won't function in a nested document, like in a $elemMatch query.
• Generally, you should use $where only when you cannot express your query via another operator. If you have to use $where , make sure you include at least one other standard query operator to filter the result set. Using $where independently requires a collection scan for proper execution.

Here's an example to illustrate this:

 db.cars.find( { $where: function() { return (hex_md5(this.name)== "9a43e617b50cd379dca1bc6e2a8") } } );

Bitwise Operators

Bitwise operators return data based on bit position conditions. Simply put, they are used to match numeric or binary values in which any bit from a set of bit positions has a value of 1 or 0.

$bitsAllSet

This operator will match all the documents where all of the bit positions provided by the query are set (ie 1) in the field:

{ <field> : { $bitsAllSet: <numeric bitmask> } }

 { <field> : { $bitsAllSet: < BinData bitmask> } }

 { <field> : { $bitsAllSet: [ <position1> , <position2> , ... ] } }

Der Feldwert sollte entweder eine BinData-Instanz oder numerisch sein, damit $bitsAllSet mit dem aktuellen Dokument übereinstimmt.

Im folgenden Fall nutzen wir eine Sammlung mit den folgenden Dokumenten:

 db.collection.save({ _id: 1, a: 54, binaryValueofA: "00110110" }) db.collection.save({ _id: 2, a: 20, binaryValueofA: "00010100" }) db.collection.save({ _id: 3, a: 20.0, binaryValueofA: "00010100" }) db.collection.save({ _id: 4, a: BinData(0, "Zg=="), binaryValueofA: "01100110" })

Die unten erwähnte Abfrage verwendet den $bitsAllSet Operator, um zu testen, ob Feld a Bits an Position 1 und Position 5 gesetzt hat, wobei das niederwertigste Bit an Position 0 wäre:

 db.collection.find( { a: { $bitsAllSet: [ 1, 5 ] } }

Diese Abfrage würde mit den folgenden Dokumenten übereinstimmen:

 { "_id" : 1, "a" : 54, "binaryValueofA" : "00110110" } { "_id" : 4, "a" : BinData(0,"Zg=="), "binaryValueofA" : "01100110" }

$bitsAllClear

Der Operator $bitsAllClear Dokumente ab, in denen alle von der Abfrage bereitgestellten Bitpositionen gelöscht oder 0 sind:

 { <field> : { $bitsAllClear: <numeric bitmask> } }

 { <field> : { $bitsAllClear: < BinData bitmask> } }

 { <field> : { $bitsAllClear: [ <position1> , <position2> , ... ] } }

Wir verwenden hier das für $bitsAllSet verwendete Beispiel, um die Verwendung von $bitsAllClear zu demonstrieren. Die folgende Abfrage würde diesen Operator verwenden, um zu prüfen, ob Feld a die Bits an den Positionen 1 und 5 gelöscht hat:

 db.collection.find( { a: { $bitsAllClear: [ 1, 5 ] } } )

Diese Abfrage würde mit den folgenden Dokumenten übereinstimmen:

 { "_id" : 2, "a" : 20, "binaryValueofA" : "00010100" } { "_id" : 3, "a" : 20, "binaryValueofA" : "00010100" }

Meta-Operatoren

Es gibt verschiedene Abfragemodifikatoren, mit denen Sie das Verhalten oder die Ausgabe einer Abfrage in MongoDB ändern können. Die Treiberschnittstellen stellen möglicherweise Cursormethoden bereit, die sie für Ihre Verwendung umschließen.

$Hinweis

MongoDB hat $hint seit v3.2 als veraltet markiert. Dieser Operator ist jedoch möglicherweise weiterhin für MongoDB-Treiber wie Go, Java, Scala, Ruby, Swift usw. verfügbar. Er kann den Abfrageoptimierer zwingen, einen bestimmten Index zu nutzen, um die Abfrage zu erfüllen, die dann entweder von document oder von erwähnt werden kann Indexname.

Sie können auch den $hint Operator verwenden, um Indizierungsstrategien und die Abfrageleistung zu testen. Nehmen Sie zum Beispiel die folgende Operation:

 db.users.find().hint( { age: 1 } )

Diese Operation würde alle Dokumente innerhalb der Sammlung mit dem Namen users zurückgeben, indem der Index für das age genutzt wird.

Sie können einen Hinweis auch erwähnen, indem Sie eines der folgenden Formulare verwenden:

 db.users.find()._addSpecial( "$hint", { age : 1 } ) db.users.find( { $query: {}, $hint: { age : 1 } } )

Wenn ein Indexfilter für die Abfrageform vorhanden ist, würde MongoDB den $hint einfach ignorieren.

$Kommentar

Mit dem $comment Operator können Sie in jedem Kontext, in dem $query erscheint, einen Kommentar an eine Abfrage anhängen. Da Kommentare an das Profilprotokoll weitergegeben werden, kann das Hinzufügen eines Kommentars die Interpretation und Verfolgung Ihres Profils erleichtern.

Sie können $comment auf drei Arten nutzen:

 db.collection.find( { <query> } )._addSpecial( "$comment", <comment> ) db.collection.find( { <query> } ).comment( <comment> ) db.collection.find( { $query: { <query> }, $comment: <comment> } )

Wenn Sie Abfrageausdrücken in anderen Kontexten Kommentare hinzufügen möchten, z. B. mit db.collection.update() , nutzen Sie den $comment -Abfrageoperator anstelle des Metaoperators.

$max

Sie können einen $max Wert angeben, um die exklusive Obergrenze für einen bestimmten Index anzugeben, um die Ergebnisse von find() . Dieser Operator gibt die Obergrenze für alle Schlüssel einer bestimmten Reihenfolge im Index an.

Mongosh gibt Ihnen die folgende max() Wrapper-Methode:

 db.collection.find( { <query> } ).max( { field1: <max value> , ... fieldN: <max valueN> } )

Sie können $max auch mit den folgenden zwei Formen erwähnen:

 db.collection.find( { <query> } )._addSpecial( "$max", { field1: <max value1> , ... fieldN: <max valueN> } ) db.collection.find( { $query: { <query> }, $max: { field1: <max value1> , ... fieldN: <max valueN> } } )

Wenn Sie beispielsweise die exklusive Obergrenze angeben möchten, denken Sie an die folgenden Operationen für eine Sammlung namens Sammlung, die einen Index { age: 1 } enthält:

 db.collection.find( { <query> } ).max( { age: 100 } ).hint( { age: 1 } )

Diese Operation beschränkt die Abfrage auf die Dokumente, bei denen das Feldalter kleiner als 100 ist, und erzwingt einen Abfrageplan, der den Index { age: 1 } von minKey bis 100 durchsucht.

$erklären

Dieser Operator gibt Ihnen Informationen über den Abfrageplan. Es gibt ein Dokument zurück, das die Indizes und Prozesse beschreibt, die zum Zurückgeben der Abfrage verwendet werden. Dies kann nützlich sein, wenn Sie versuchen, eine Abfrage zu optimieren.

Sie können den $explain Operator in einer der folgenden Formen erwähnen:

 db.collection.find()._addSpecial( "$explain", 1 ) db.collection.find( { $query: {}, $explain: 1 } )

Best Practices für MongoDB-Operatoren

In diesem Abschnitt werfen wir einen Blick auf einige der Best Practices bei der Verwendung dieser MongoDB-Operatoren.

Einbetten und Referenzieren

Das Einbetten ist eine natürliche Erweiterung der Datenmodellierung. Dadurch können Sie Anwendungsverknüpfungen vermeiden, wodurch Aktualisierungen und Abfragen reduziert werden können.

Sie können Daten mit einer 1:1-Beziehung in ein einzelnes Dokument einbetten. Allerdings können auch Daten mit einer Viele:1-Beziehung, in der „viele“ Objekte mit ihren übergeordneten Dokumenten erscheinen, gute Kandidaten sein.

Das Speichern dieser Datentypen im selben Dokument klingt nach einer umsichtigen Entscheidung. Das Einbetten bietet jedoch eine bessere Leistung für Lesevorgänge mit dieser Art von Datenlokalität.

Eingebettete Datenmodelle können Entwicklern auch dabei helfen, zugehörige Daten in einem einzigen Schreibvorgang zu aktualisieren. Dies funktioniert, weil das Schreiben einzelner Dokumente transaktional ist.

Sie sollten die Verwendung von Referenzen für die folgenden Szenarien in Betracht ziehen:

• Wenn Sie ein Dokumentsegment aktualisieren und es immer länger wird, während der Rest des Dokuments statisch ist.
• Wenn auf ein Dokument zugegriffen wird, das jedoch Daten enthält, die selten verwendet werden. Das Einbetten würde nur die In-Memory-Anforderungen erhöhen, daher ist eine Referenzierung sinnvoller.
• Wenn die Dokumentgröße das Dokumentenlimit von MongoDB von 16 MB überschreitet. Dies kann passieren, wenn viele:1-Beziehungen modelliert werden (z. B. employee:department ).

Untersuchen Sie Profilerstellung und Abfragemuster

Für die meisten Entwickler besteht der erste Schritt zur Optimierung der Leistung darin, die tatsächlichen und erwarteten Abfragemuster zu verstehen. Sobald Sie die Abfragemuster Ihrer Anwendung gut genug kennen, können Sie Ihr Datenmodell erstellen und geeignete Indizes auswählen.

MongoDB-Entwickler haben Zugriff auf verschiedene leistungsstarke Tools, mit denen sie die Leistung verbessern können. Das bedeutet jedoch nicht, dass Abfrageprofile und -muster ignoriert werden können.

Eine einfache Möglichkeit, die Leistung zu steigern, besteht beispielsweise darin, Ihre Abfragemuster zu analysieren und zu verstehen, wo Sie Daten einbetten können. Andere Möglichkeiten, die Leistung von MongoDB zu verbessern, nachdem Sie Ihre wichtigsten Abfragemuster identifiziert haben, sind:

• Stellen Sie sicher, dass Sie Indizes für alle Felder haben, die Sie abfragen.
• Speichern der Ergebnisse häufiger Unterabfragen von Dokumenten, um die Leselast zu reduzieren.
• Sehen Sie sich Ihre Protokolle an, um nach langsamen Abfragen zu suchen, und überprüfen Sie dann Ihre Indizes.

Überprüfen Sie die Datenindizierung und -modellierung

Während Sie Ihr Datenmodell erstellen, entscheiden Sie, wie Sie Beziehungen zwischen Daten modellieren. Die Entscheidung, wann ein Dokument eingebettet werden soll, statt stattdessen eine Referenz über separate Dokumente in verschiedenen Sammlungen zu erstellen, ist beispielsweise ein Beispiel für eine anwendungsspezifische Überlegung.

Ein großer Vorteil von JSON-Dokumenten besteht darin, dass sie es Entwicklern ermöglichen, Daten basierend auf den Anforderungen der Anwendung zu modellieren. Das Verschachteln von Filialdokumenten und Arrays hilft Ihnen, komplexe Beziehungen zwischen Daten zu modellieren, indem Sie einfache Textdokumente nutzen.

Sie können MongoDB auch verwenden, um Folgendes zu modellieren:

• Geodaten
• Tabellarische, flache und säulenförmige Strukturen
• Einfache Schlüssel-Wert-Paare
• Zeitreihendaten
• Kanten und Knoten verbundener Graphdatenstrukturen und dergleichen

Sharding und Replikation überwachen

Die Replikation kann entscheidend für die Verbesserung der Leistung sein, da sie die Datenverfügbarkeit durch horizontale Skalierung erhöht. Replikation kann durch Redundanz zu besserer Leistung und mehr Sicherheit führen.

Die Leistungsüberwachung kann mühsam sein, da zusätzliche Ressourcen und Zeit benötigt werden, um ein reibungsloses Funktionieren zu gewährleisten. Sie können auf dem Markt erhältliche Tools zur Leistungsüberwachung nutzen, die Ihren spezifischen Anforderungen entsprechen.

Zum Beispiel kann Kinsta APM zeitgestempelte Informationen über die MySQL-Datenbankabfragen deiner WordPress-Seite, PHP-Prozesse, externe HTTP-Aufrufe und vieles mehr abrufen. Sie können auch dieses kostenlose Tool zum Debuggen verwenden:

• Lange API-Aufrufe
• Lange externe URL-Anforderungen
• Langsame Datenbankabfragen, um nur einige zu nennen.

In MongoDB kann die Replikation durch Replikatsätze erreicht werden, mit denen Entwickler Daten von einem primären Knoten oder Server über mehrere sekundäre Knoten kopieren können. Dadurch kann Ihre Replikation einige Abfragen auf sekundären statt auf primären ausführen, wodurch Konflikte vermieden und ein besserer Lastausgleich erreicht werden.

Sharded-Cluster in MongoDB sind eine weitere Möglichkeit, die Leistung potenziell zu verbessern. Ähnlich wie bei der Replikation kann Sharding verwendet werden, um große Datensätze auf mehrere Server zu verteilen.

Durch die Nutzung eines Shard-Schlüssels können Entwickler Shards oder Datenteile über mehrere Server hinweg kopieren. Diese Server können zusammenarbeiten, um alle Daten zu verwenden.

Sharding hat seinen gerechten Anteil an Vorteilen, einschließlich horizontaler Skalierung für Schreib-/Lesevorgänge, höhere Verfügbarkeit und erhöhte Speicherkapazität.

Bestimmen Sie die Speichernutzung

MongoDB schneidet am besten ab, wenn der Arbeitssatz einer Anwendung (dh Daten und Indizes, auf die häufig zugegriffen wird) ohne Probleme in den Arbeitsspeicher passt. Während andere Faktoren für die Leistung ausschlaggebend sind, ist die RAM-Größe für die Instanzgröße am wichtigsten.

Wenn der Arbeitssatz einer Anwendung in den RAM passt, muss die Leseaktivität von der Festplatte niedrig sein. Wenn Ihr Arbeitssatz jedoch den Arbeitsspeicher oder die Größe des Instanzservers überschreitet, beginnt die Leseaktivität in die Höhe zu schießen.

Wenn dies auftritt, können Sie das Problem möglicherweise lösen, indem Sie zu einer größeren Instanz mit mehr Arbeitsspeicher wechseln.

Platzieren Sie Mehrwertige Felder am Ende

Wenn Sie mehrere Felder indizieren und eines der Felder, die Sie abfragen möchten, einen dieser „mehrwertigen“ Operatoren verwendet, sollten Sie sie am Ende des Indexes platzieren. Sie müssen den Index so ordnen, dass die abgefragten Felder für exakte Werte zuerst kommen und die „mehrwertigen“ Operatoren zuletzt im Index erscheinen.

Eine Ausnahme hiervon wäre das Sortieren nach den Feldern. Platzieren Sie diese zwischen den Feldern „mehrwertig“ und „exakt“, um den Umfang der erforderlichen In-Memory-Sortierung zu reduzieren.

Zusammenfassung

Für MongoDB ist Geschwindigkeit der Name des Spiels. Um Abfragen schnell zurückzugeben, nutzt MongoDB Operatoren, um mathematische oder logische Aufgaben auszuführen. Einfach ausgedrückt ist das Verständnis von MongoDB-Operatoren der Schlüssel zur Beherrschung von MongoDB.

In diesem Artikel wurden einige der wichtigsten MongoDB-Operatoren hervorgehoben, die Sie für Ihre Daten verwenden können, z. B. Vergleichsoperatoren, logische Operatoren, Metaoperatoren und Projektionsoperatoren, um nur einige zu nennen. Es hilft Ihnen auch zu verstehen, wie Sie MongoDB-Operatoren verwenden können, und zeigt die Best Practices, mit denen Sie das Beste aus ihnen herausholen können.

Welche von allen Operatoren verwenden Sie am häufigsten und warum? Teilen Sie die Kommentare unten mit - wir würden uns freuen, Ihre Gedanken zu hören!