Einführung in MongoDB-Datentypen

Einführung

Wenn Sie MongoDB verwenden, haben Sie die Möglichkeit, bei der Struktur Ihrer Daten flexibel zu sein. Sie sind nicht an ein bestimmtes Schema gebunden, in das alle Ihre Dokumente passen müssen. Für jedes beliebige Feld in einem Dokument können Sie jeden der verfügbaren Datentypen verwenden von MongoDB unterstützt. Trotz dieser standardmäßigen Arbeitsweise können Sie ein JSON-Schema in MongoDB auferlegen, um Ihren Sammlungen bei Bedarf eine Validierung hinzuzufügen. Wir werden in diesem Handbuch nicht auf die Details des Schemadesigns eingehen, aber es kann Auswirkungen auf die Datentypisierung haben, wenn es implementiert wird.

Datentypen geben ein allgemeines Muster für die Daten an, die sie akzeptieren und speichern. Es ist von größter Bedeutung zu verstehen, wann Sie bei der Planung Ihrer Datenbank einen bestimmten Datentyp einem anderen vorziehen sollten. Der gewählte Typ bestimmt, wie Sie mit Ihren Daten arbeiten und wie sie gespeichert werden.

JSON und BSON

Bevor Sie sich mit den Details bestimmter Datentypen befassen, ist es wichtig, zu verstehen, wie MongoDB Daten speichert. MongoDB und viele andere dokumentbasierte NoSQL-Datenbanken verwenden JSON (JavaScript Object Notation), um Datensätze als Dokumente darzustellen.

Die Verwendung von JSON zum Speichern von Daten bietet viele Vorteile. Einige davon sind:

Einfach zu lesen, zu lernen und seine Vertrautheit unter Entwicklern
Flexibilität im Format, ob spärlich, hierarchisch oder tief verschachtelt
selbstbeschreibend, wodurch Anwendungen problemlos mit JSON-Daten arbeiten können
ermöglicht die Konzentration auf eine minimale Anzahl von Grundtypen

JSON unterstützt alle grundlegenden Datentypen wie Zeichenfolgen, Zahlen, boolesche Werte usw. MongoDB speichert Datensätze tatsächlich als binärcodierte JSON-Dokumente (BSON). Wie JSON unterstützt BSON das Einbetten von Dokumenten und Arrays in andere Dokumente und Arrays. BSON ermöglicht zusätzliche Datentypen, die JSON nicht zur Verfügung stehen.

Welche Datentypen gibt es in MongoDB?

Bevor wir ins Detail gehen, werfen wir einen umfassenden Überblick darüber, welche Datentypen in MongoDB unterstützt werden.

MongoDB unterstützt eine Reihe von Datentypen, die für verschiedene Arten einfacher und komplexer Daten geeignet sind. Dazu gehören:

Text

String

Numerisch

32-Bit Integer
64-Bit Integer
Double
Decimal128

Datum/Uhrzeit

Date
Timestamp

Andere

Object
Array
Binary Data
ObjectId
Boolean
Null
Regular Expression
JavaScript
Min Key
Max Key

In MongoDB hat jeder BSON-Typ sowohl eine Ganzzahl als auch Zeichenfolgenkennungen. Wir werden die häufigsten davon in diesem Leitfaden ausführlicher behandeln.

String-Typen

Der String-Typ ist der am häufigsten verwendete MongoDB-Datentyp. Jeder Wert, der in doppelte Anführungszeichen "" geschrieben wird in JSON ist ein Zeichenfolgenwert. Jeder Wert, der als Text gespeichert werden soll, wird am besten als String eingegeben . BSON-Strings sind UTF-8 und werden in MongoDB wie folgt dargestellt:

        Type         | Number |  Alias   |  ------------------ | ------ | -------- |       String        |    2   | "string" |

Im Allgemeinen konvertieren Treiber für Programmiersprachen beim Serialisieren und Deserialisieren von BSON vom Zeichenfolgenformat der Sprache in UTF-8. Dies macht BSON zu einer attraktiven Methode, um beispielsweise internationale Zeichen einfach zu speichern.

Einfügen eines Dokuments mit einem String Der Datentyp sieht in etwa so aus:

db.mytestcoll.insertOne({first_name: "Alex"}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d15")}

Das Abfragen der Sammlung gibt Folgendes zurück:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d15"),         first_name: "Alex"}

Verwenden des `$type` Betreiber

Bevor Sie mit unserem nächsten Datentyp fortfahren, ist es wichtig zu wissen, wie Sie den Wert vor dem Einfügen überprüfen können. Wir verwenden das vorherige Beispiel, um die Verwendung von $type zu demonstrieren Operator in MongoDB.

Nehmen wir an, es ist schon eine Weile her, seit wir mit mytestcoll gearbeitet haben Sammlung von früher. Wir wollen einige zusätzliche Dokumente in die Sammlung mit dem first_name einfügen Feld. Um zu überprüfen, ob wir String verwendet haben als Datentyp gespeichert als Wert von first_name Ursprünglich können wir Folgendes ausführen, indem wir entweder den Alias oder den Zahlenwert des Datentyps verwenden:

db.mytestcoll.find( { "first_name": { $type: "string" } } )

Oder

db.mytestcoll.find( { "first_name": { $type: 2 } } )

Beide Abfragen geben eine Ausgabe aller Dokumente zurück, die einen String haben Wert, der für first_name gespeichert ist aus der Einfügung unseres vorherigen Abschnitts:

[ { _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex" } ]

Wenn Sie einen Typ abfragen, der nicht in first_name gespeichert ist Feld eines beliebigen Dokuments, erhalten Sie kein Ergebnis. Dies zeigt an, dass es sich um einen anderen Datentyp handelt, der in first_name gespeichert ist .

Mit $type können Sie auch mehrere Datentypen gleichzeitig abfragen Operator wie folgt:

db.mytestcoll.find( { "first_name": { $type: ["string", "null"] } } )

Weil wir keine Null eingefügt haben Geben Sie Werte in unsere Sammlung ein, das Ergebnis ist dasselbe:

[ { _id: ObjectId("614b37296a124db40ae74d15"), first_name: "Alex" } ]

Sie können die gleiche Methode mit allen folgenden Typen verwenden, die wir besprechen werden.

Zahlen und numerische Werte

MongoDB enthält eine Reihe numerischer Datentypen, die für verschiedene Szenarien geeignet sind. Die Entscheidung, welcher Typ verwendet werden soll, hängt von der Art der Werte ab, die Sie speichern möchten, und von Ihren Anwendungsfällen für die Daten. JSON nennt alles mit Zahlen eine Zahl . Das zwingt das System, herauszufinden, wie es in den nächsten nativen Datentyp umgewandelt werden kann. Wir beginnen mit der Untersuchung von Ganzzahlen und ihrer Funktionsweise in MongoDB.

Ganzzahl

Die Integer Der Datentyp wird verwendet, um Zahlen als ganze Zahlen ohne Brüche oder Dezimalstellen zu speichern. Ganzzahlen können entweder positive oder negative Werte sein. Es gibt zwei Typen in MongoDB, 32-Bit Integer und 64-Bit Integer . Sie können auf zwei Arten dargestellt werden, die in der folgenden Tabelle dargestellt sind, number und alias :

  Integer type   | number |    alias     |   ------------   | -----  | ------------ |  `32-bit integer`|   16   |    "int"     | `64-bit integer`|   18   |    "long"    |

Die Bereiche, in die ein Wert für jeden Typ passen kann, sind die folgenden:

  Integer type   |    Applicable signed range     |    Applicable unsigned range    |  ------------   | ------------------------------ | ------------------------------- | `32-bit integer`| -2,147,483,648 to 2,147,483,647|  0 to 4,294,967,295             | `64-bit integer`| -9,223,372,036,854,775,808 to  |  0 to 18,446,744,073,709,551,615                         9,223,372,036,854,775,807

Die oben genannten Typen sind durch ihren gültigen Bereich begrenzt. Jeder Wert außerhalb des Bereichs führt zu einem Fehler. Einfügen einer Integer Typ in MongoDB sieht wie folgt aus:

db.mytestcoll.insertOne({age: 26}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d14")}

Wenn Sie das Ergebnis finden, wird Folgendes zurückgegeben:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d14"), age: 26}

Wie der Name schon sagt, ein 32-Bit Integer hat 32 Bit ganzzahlige Genauigkeit, was für kleinere ganzzahlige Werte nützlich ist, die Sie nicht als Ziffernfolge speichern möchten. Wenn Sie in der Zahlengröße wachsen, können Sie bis zur 64-Bit Integer aufsteigen die 64-Bit-Integer-Präzision hat und für denselben Anwendungsfall wie die erstere geeignet ist.

Doppelt

In BSON der Standardersatz für die Number von JSON ist das Double Datentyp. Das Double Der Datentyp wird zum Speichern eines Gleitkommawerts verwendet und kann in MongoDB wie folgt dargestellt werden:

        Type         | Number |   Alias  |  ------------------ | ------ | -------- |       Double        |    1   | "double" |

Fließkommazahlen sind eine weitere Möglichkeit, Dezimalzahlen auszudrücken, jedoch ohne exakte, konsistente Genauigkeit.

Fließkommazahlen können mit einer großen Anzahl von Dezimalstellen effizient arbeiten, aber nicht immer genau. Nachfolgend sehen Sie ein Beispiel für die Eingabe eines Dokuments mit dem Double Geben Sie in Ihre Sammlung ein:

db.mytestcoll.insertOne({testScore: 89.6}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d13")}

Beim Rechnen mit Doubles kann es zu geringfügigen Abweichungen zwischen Eingabe und Ausgabe kommen, die möglicherweise zu unerwartetem Verhalten führen können. Beim Ausführen von Operationen, die genaue Werte erfordern, hat MongoDB einen genaueren Typ.

Dezimal128

Wenn Sie mit sehr großen Zahlen mit viel Fließkommabereich arbeiten, dann ist Decimal128 Der Datentyp BSON ist die beste Option. Dies ist der nützlichste Typ für Werte, die viel Präzision erfordern, z. B. in Anwendungsfällen mit exakten Geldoperationen. Der Decimal128 Typ wird dargestellt als:

        Type         | Number |   Alias   |  ------------------ | ------ | --------- |      Decimal128     |   19   | "decimal" |

Der BSON-Typ, Decimal128 , bietet eine 128-Bit-Dezimaldarstellung zum Speichern von Zahlen, bei denen das exakte Runden von Dezimalstellen wichtig ist. Decimal128 unterstützt 34 Dezimalstellen oder einen Sinifikanden mit einem Bereich von -6143 bis +6144. Dies ermöglicht ein hohes Maß an Präzision.

Einfügen eines Werts mit Decimal128 Datentyp erfordert die Verwendung von NumberDecimal() Konstruktor mit Ihrer Nummer als String um zu verhindern, dass MongoDB den numerischen Standardtyp Double verwendet .

Hier demonstrieren wir dies:

db.mytestcoll.insertOne({price : NumberDecimal("5.099")}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d12")}

Beim Abfragen der Collection erhalten Sie dann folgende Rückgabe:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d12"),         price: "5.099" }

Der numerische Wert behält seine Genauigkeit bei, was exakte Operationen ermöglicht. Um den Decimal128 zu demonstrieren Typ gegen Double , können wir die folgende Übung durchführen.

Wie Präzision je nach Datentyp verloren gehen kann

Angenommen, wir möchten eine Zahl mit vielen Dezimalwerten als Double einfügen in MongoDB mit dem folgenden:

db.mytestcoll.insertOne({ price: 9999999.4999999999 }){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d24")}

Wenn wir diese Daten abfragen, erhalten wir das folgende Ergebnis:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d24"),         price: 9999999.5}

Dieser Wert wird auf 9999999.5 aufgerundet , wodurch der exakte Wert verloren geht, mit dem wir ihn eingegeben haben. Das ergibt Double ungeeignet für die Speicherung von Zahlen mit vielen Dezimalstellen.

Das nächste Beispiel zeigt, wo Genauigkeit verloren geht, wenn ein Double übergeben wird implizit mit Decimal128 anstelle eines String wie im vorherigen Beispiel.

Wir beginnen mit dem Einfügen des folgenden Double wieder, aber mit NumberDecimal() um es zu einem Decimal128 zu machen Typ:

db.mytestcoll.insertOne({ price: NumberDecimal( 9999999.4999999999 ) }){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d14")}

Hinweis :Wenn Sie diese Einfügung in der MongoDB-Shell vornehmen, wird die folgende Warnmeldung angezeigt:

Warning: NumberDecimal: specifying a number as argument is deprecated and may lead to loss of precision, pass a string instead

Diese Warnmeldung weist darauf hin, dass die Zahl, die Sie zu übergeben versuchen, einem Genauigkeitsverlust unterliegen könnte. Sie schlagen vor, einen String zu verwenden mit NumberDecimal() damit Sie keine Genauigkeit verlieren.

Wenn wir die Warnung ignorieren und das Dokument trotzdem einfügen, zeigt sich der Genauigkeitsverlust in den Abfrageergebnissen durch das Aufrunden des Werts:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d14"),         price: Decimal128("9999999.50000000")}

Wenn wir dem empfohlenen NumberDecimal() folgen Ansatz mit einem String Wir sehen die folgenden Ergebnisse mit beibehaltener Genauigkeit:

db.mytestcoll.insertOne({ price: NumberDecimal( "9999999.4999999999" ) } )

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d14"),         price: Decimal128("9999999.4999999999")}

Für jeden Anwendungsfall, der genaue, exakte Werte erfordert, kann diese Rückgabe Probleme verursachen. Jede Arbeit, die Geldoperationen beinhaltet, ist ein Beispiel, bei dem Präzision extrem wichtig ist und genaue Werte für genaue Berechnungen entscheidend sind. Diese Demonstration unterstreicht, wie wichtig es ist, zu wissen, welcher numerische Datentyp für Ihre Daten am besten geeignet ist.

Datum

Das BSON Date Der Datentyp ist eine 64-Bit-Ganzzahl, die die Anzahl der Millisekunden seit der Unix-Epoche (1. Januar 1970) darstellt. Dieser Datentyp speichert das aktuelle Datum oder die Uhrzeit und kann entweder als Datumsobjekt oder als Zeichenfolge zurückgegeben werden. Date wird in MongoDB wie folgt dargestellt:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |        Date         |    9   |     "date"   |

Hinweis :BSON Date Typ ist signiert. Negative Werte stellen Daten vor 1970 dar.

Es gibt drei Methoden zum Zurückgeben von Datumswerten.

Date() - gibt eine Zeichenkette
zurück
new Date() - gibt ein Datumsobjekt mit ISODate() zurück Verpackung
ISODate() - gibt auch ein Datumsobjekt mit ISODate() zurück Verpackung

Wir demonstrieren diese Optionen unten:

var date1 = Date()var date2 = new Date()var date3 = ISODate()db.mytestcoll.insertOne({firstDate: date1, secondDate: date2, thirdDate: date3}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d22")}

Und bei der Rückkehr:

db.mytestcoll.find().pretty(){                "_id" : ObjectId("614b37296a124db40ae74d22"),                firstDate: 'Tue Sep 28 2021 11:28:52 GMT+0200 (Central European Summer Time)',                secondDate: ISODate("2021-09-28T09:29:01.924Z"),                thirdDate: ISODate("2021-09-28T09:29:12.151Z")}

Zeitstempel

Es gibt auch den Timestamp Datentyp in MongoDB zur Darstellung der Zeit. Allerdings Timestamp wird für den internen Gebrauch am nützlichsten sein und nicht dem Date zugeordnet Typ. Der Typ selbst ist eine Zeichenfolge, die verwendet wird, um Datum und Uhrzeit des Auftretens eines Ereignisses zu beschreiben. Timestamp ist ein 64-Bit-Wert, wobei:

die signifikantesten 32 Bits sind time_t Wert (Sekunden seit der Unix-Epoche)
die niedrigstwertigen 32 Bits sind eine inkrementierende ordinal für Operationen innerhalb einer bestimmten Sekunde

Seine Darstellung in MongoDB sieht wie folgt aus:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      Timestamp      |   17   |  "timestamp" |

Beim Einfügen eines Dokuments, das Felder der obersten Ebene mit leeren Zeitstempeln enthält, ersetzt MongoDB den leeren Zeitstempelwert durch den aktuellen Zeitstempelwert. Die Ausnahme hiervon ist, wenn die _id Feld enthält einen leeren Zeitstempel. Der Zeitstempelwert wird immer unverändert eingefügt und nicht ersetzt.

Einfügen eines neuen Timestamp -Wert in MongoDB verwendet den new Timestamp() funktionieren und ungefähr so aussehen:

db.mytestcoll.insertOne( {ts: new Timestamp() });{        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d23")}

Wenn Sie die Sammlung abfragen, geben Sie ein Ergebnis zurück, das dem folgenden ähnelt:

db.mytestcoll.find().pretty(){        "_id" : ObjectId("614b37296a124db40ae74d24"),         "ts" : Timestamp( { t: 1412180887, i: 1 })}

Objekt

Das Object Der Datentyp in MongoDB wird zum Speichern eingebetteter Dokumente verwendet. Ein eingebettetes Dokument ist eine Reihe von verschachtelten Dokumenten in key: value Paarformat. Wir demonstrieren das Object Geben Sie unten ein:

var classGrades = {"Physics": 88, "German": 92, "LitTheoery": 79}db.mytestcoll.insertOne({student_name: "John Smith", report_card: classGrades}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d18")}

Wir können dann unser neues Dokument anzeigen:

db.mytestcoll.find().pretty(){    _id: ObjectId("614b37296a124db40ae74d18"),    student_name: 'John Smith',    report_card: {Physics: 88, German: 92, LitTheoery: 79}}

Das Object Datentyp optimiert für das Speichern von Daten, auf die am besten zusammen zugegriffen wird. Es bietet einige Effizienzvorteile in Bezug auf Speicherung, Geschwindigkeit und Haltbarkeit im Gegensatz zur separaten Speicherung jeder Klassenmarkierung aus dem obigen Beispiel.

Binärdaten

Die Binary Data , oder BinData , macht der Datentyp genau das, was sein Name andeutet, und speichert binäre Daten für den Wert eines Felds. BinData wird am besten verwendet, wenn Sie Daten speichern und suchen, da es Bit-Arrays effizient darstellt. Dieser Datentyp kann auf folgende Weise dargestellt werden:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      Binary data    |    5   |   "binData"  |

Hier ist ein Beispiel für das Hinzufügen einiger Binary Data in ein Dokument in einer Sammlung:

var data = BinData(1, "111010110111100110100010101")db.mytestcoll.insertOne({binaryData: data}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d20")}

Um dann das resultierende Dokument zu sehen:

db.mytestcoll.find().pretty(){        "_id" : ObjectId("614b37296a124db40ae74d20"),        "binaryData" : BinData(1, "111010110111100110100010101")}

ObjektID

Die ObjectId type ist spezifisch für MongoDB und speichert die eindeutige ID des Dokuments. MongoDB stellt eine _id bereit Feld für jedes Dokument. ObjectId ist 12 Bytes groß und kann wie folgt dargestellt werden:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      ObjectId       |    7   |   "objectId" |

ObjectId besteht aus drei Teilen, die seine 12-Byte-Struktur bilden:

ein 4-Byte-Zeitstempelwert , die die Erstellung der ObjectId darstellt, gemessen in Sekunden seit der Unix-Epoche
ein 5-Byte-Zufallswert
ein 3-Byte-Inkrementierungszähler mit einem zufälligen Wert initialisiert

In MongoDB benötigt jedes Dokument innerhalb einer Sammlung eine eindeutige _id als Primärschlüssel fungieren. Wenn die _id Feld für ein eingefügtes Dokument leer gelassen wird, generiert MongoDB automatisch eine ObjectId für das Feld.

Die Verwendung von ObjectIds für _id bietet mehrere Vorteile :

im mongosh (MongoDB-Shell), die Erstellungszeit der ObjectId ist über ObjectId.getTimestamp() zugänglich Methode.
Sortierung nach _id Feld, das ObjectId speichert Datentypen entspricht in etwa der Sortierung nach Erstellungszeit.

Wir haben bisher in allen Beispielen ObjectIds gesehen, und sie sehen ungefähr so aus:

db.mytestcoll.find().pretty(){         _id: ObjectId("614b37296a124db40ae74d19")}

Hinweis :ObjectId-Werte sollten mit der Zeit ansteigen, sie sind jedoch nicht unbedingt monoton. Dies liegt daran, dass sie:

Enthalten nur eine Sekunde zeitliche Auflösung, daher haben Werte, die innerhalb derselben Sekunde erstellt wurden, keine garantierte Reihenfolge
Werte werden von Clients generiert, die unterschiedliche Systemuhren haben können

Boolean

MongoDB hat den nativen Boolean Datentyp zum Speichern von wahren und falschen Werten innerhalb einer Sammlung. Boolean in MongoDB kann wie folgt dargestellt werden:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |       Boolean       |    8   |     "bool"   |

Einfügen eines Dokuments mit einem Boolean Der Datentyp sieht in etwa so aus:

db.mytestcoll.insertOne({isCorrect: true, isIncorrect: false}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d21")}

Wenn Sie dann nach dem Dokument suchen, wird das Ergebnis wie folgt angezeigt:

db.mytestcoll.find().pretty(){    "_id" : ObjectId("614b37296a124db40ae74d21")    "isCorrect" : true,    "isIncorrect" : false}

Regulärer Ausdruck

Der Regular Expression Der Datentyp in MongoDB ermöglicht die Speicherung regulärer Ausdrücke als Wert eines Felds. MongoDB verwendet PCRE (Perl-kompatibler regulärer Ausdruck) als Sprache für reguläre Ausdrücke.

Es kann folgendermaßen dargestellt werden:

        Type         | Number |  Alias  |  ------------------ | ------ | ------- |  Regular Expression |   11   | "regex" |

Mit BSON können Sie den typischen Schritt „Konvertieren aus Zeichenfolge“ vermeiden, der häufig bei der Arbeit mit regulären Ausdrücken und Datenbanken auftritt. Dieser Typ ist am nützlichsten, wenn Sie Datenbankobjekte schreiben, die Validierungsmuster oder übereinstimmende Trigger erfordern.

Beispielsweise können Sie den Regular Expression einfügen Datentyp wie folgt:

db.mytestcoll.insertOne({exampleregex: /tt/}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d16")}db.mytestcoll.insertOne({exampleregext:/t+/}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d17")}

Diese Abfolge von Anweisungen fügt diese Dokumente Ihrer Sammlung hinzu. Sie können dann Ihre Sammlung abfragen, um die eingefügten Dokumente zu finden:

db.mytestcoll.find().pretty(){        _id: ObjectId("614b37296a124db40ae74d16"), exampleregex: /tt/,        _id: ObjectId("614b37296a124db40ae74d17"), exampleregex: /t+/ }

Die regulären Ausdrucksmuster werden als Regex und nicht als Strings gespeichert. Auf diese Weise können Sie eine bestimmte Zeichenfolge abfragen und Dokumente mit einem regulären Ausdruck erhalten, der mit der gewünschten Zeichenfolge übereinstimmt.

JavaScript (ohne Geltungsbereich)

Ähnlich wie der zuvor erwähnte Regular Expression Datentyp BSON ermöglicht es MongoDB, JavaScript-Funktionen ohne Gültigkeitsbereich als ihren eigenen Typ zu speichern. Das JavaScript Typ kann wie folgt erkannt werden:

        Type         | Number |     Alias    |  ------------------ | ------ | ------------ |      JavaScript     |   13   | "javascript" |

Hinzufügen eines Dokuments zu Ihrer Sammlung mit JavaScript Der Datentyp sieht in etwa so aus:

db.mytestcoll.insertOne({jsCode: "function(){var x; x=1}"}){        "acknowledged": true,        "insertedId": ObjectId("614b37296a124db40ae74d122")}

Mit dieser Funktion können Sie JavaScript-Funktionen in Ihren MongoDB-Sammlungen speichern, wenn dies für einen bestimmten Anwendungsfall erforderlich ist.

Hinweis :Ab MongoDB-Version 4.4 ein alternativer JavaScript-Typ, das JavaScript with Scope Datentyp, ist veraltet

Fazit

In diesem Artikel haben wir die meisten gängigen Datentypen behandelt, die beim Arbeiten mit MongoDB-Datenbanken nützlich sind. Es gibt zusätzliche Typen, die in diesem Handbuch nicht explizit behandelt werden und je nach Anwendungsfall hilfreich sein können. Die ersten Schritte mit der Kenntnis dieser Typen decken die meisten Anwendungsfälle ab. Es ist eine solide Grundlage, um mit der Modellierung Ihrer MongoDB-Datenbank zu beginnen.

Es ist wichtig zu wissen, welche Datentypen Ihnen zur Verfügung stehen, wenn Sie eine Datenbank verwenden, damit Sie gültige Werte verwenden und die Daten mit den erwarteten Ergebnissen bearbeiten. Es gibt Risiken, auf die Sie stoßen können, wenn Sie Ihre Daten nicht richtig eingeben, wie im Double demonstriert gegenüber Decimal128 die Übung. Es ist wichtig, darüber nachzudenken, bevor Sie sich auf einen bestimmten Typ festlegen.

Wenn Sie daran interessiert sind, Prisma mit einer MongoDB-Datenbank auszuprobieren, können Sie sich die Dokumentation zum Datenkonnektor ansehen.