Share
NoSQL Datenbanken sind in den letzten Jahren aufgrund ihrer weniger beschränkten Struktur, ihres skalierbaren Schemendesigns und ihres schnelleren Zugriffs im Vergleich zu traditionellen relationalen Datenbanken (RDBMS / SQL) enorm gewachsen. MongoDB ist eine Open Source-Dokument-orientierte NoSQL-Datenbank, in der Daten in Form von JSON-artigen Objekten gespeichert werden. Aufgrund ihres dynamischen Schemas, der hohen Skalierbarkeit, der optimalen Abfrageleistung, der schnelleren Indizierung und einer aktiven Benutzergemeinschaft hat sich die Datenbank zu einer der führenden Datenbanken entwickelt.
Wenn Sie aus einem RDBMS / SQL-Hintergrund stammen, kann das Verstehen der NoSQL- und MongoDB-Konzepte beim Start etwas schwierig sein, da beide Technologien eine sehr unterschiedliche Art der Datendarstellung haben. In diesem Artikel erfahren Sie, wie die RDBMS / SQL-Domäne, ihre Funktionen, Begriffe und Abfragesprache der MongoDB-Datenbank zugeordnet werden. Mit Mapping meine ich, dass wir, wenn wir ein Konzept in RDBMS / SQL haben, sehen werden, was das entsprechende Konzept in MongoDB ist.
Wir beginnen mit der Abbildung der relationalen Grundkonzepte wie Tabelle, Zeile, Spalte usw. und gehen dann zur Erörterung der Indizierung und der Verknüpfungen über. Wir werden dann die SQL-Abfragen durchsehen und die entsprechenden MongoDB-Datenbankabfragen besprechen. In diesem Artikel wird davon ausgegangen, dass Sie mit den grundlegenden Konzepten der relationalen Datenbank und mit SQL vertraut sind, da im gesamten Artikel mehr Wert darauf gelegt wird, wie diese Konzepte in MongoDB abgebildet werden. Lass uns anfangen.
Jede Datenbank in MongoDB besteht aus Sammlungen, die einer aus SQL-Tabellen bestehenden RDBMS-Datenbank entsprechen. In jeder Sammlung werden Daten in Form von Dokumenten gespeichert. Dies entspricht Tabellen, die Daten in Zeilen speichern. Während eine Zeile Daten in ihrem Spaltensatz speichert, hat ein Dokument eine JSON-ähnliche Struktur (in MongoDB als BSON bezeichnet). Auf die Art, wie wir Zeilen in einer SQL-Zeile haben, haben wir Felder in MongoDB. Das folgende Beispiel zeigt ein Dokument (Lesezeile) mit einigen Feldern (Lesespalten), in denen Benutzerdaten gespeichert sind:
Accentsconagua
"_id": ObjectId ("5146bb52d8524270060001f3"), "age": 25, "city": "Los Angeles", "email": "[email protected]", "benutzername": "Mark Hanks" Dieses Dokument entspricht einer einzelnen Zeile in RDBMS. Eine Sammlung besteht aus vielen solchen Dokumenten, ebenso wie eine Tabelle aus vielen Zeilen besteht. Beachten Sie, dass jedes Dokument in einer Sammlung eindeutig ist _Ich würde field, ein 12-Byte-Feld, das als Primärschlüssel für die Dokumente dient. Das Feld wird bei der Erstellung des Dokuments automatisch generiert und zur eindeutigen Identifizierung jedes Dokuments verwendet.
Um die Zuordnungen besser zu verstehen, nehmen wir ein Beispiel einer SQL-Tabelle Benutzer und seine entsprechende Struktur in MongoDB. Wie in Abbildung 1 dargestellt, wird jede Zeile in der SQL-Tabelle in ein Dokument und jede Spalte in ein Feld in MongoDB umgewandelt.
Interessant ist hier, dass verschiedene Dokumente innerhalb einer Sammlung unterschiedliche Schemata haben können. So ist es in MongoDB möglich, dass ein Dokument fünf Felder und das andere Dokument sieben Felder hat. Die Felder können jederzeit problemlos hinzugefügt, entfernt und geändert werden. Es gibt auch keine Einschränkung für die Datentypen der Felder. In einem Fall kann also ein Feld halten int Typdaten und bei der nächsten Instanz kann es eine Array.
Diese Konzepte müssen sich für Leser, die aus dem RDBMS-Hintergrund stammen, sehr unterscheiden, wobei die Tabellenstrukturen, ihre Spalten, Datentypen und Beziehungen vordefiniert sind. Diese Funktionalität zur Verwendung eines dynamischen Schemas ermöglicht die Erzeugung dynamischer Dokumente zur Laufzeit.
Betrachten Sie beispielsweise die folgenden zwei Dokumente innerhalb derselben Sammlung, jedoch mit unterschiedlichen Schemata (Abb. 2):
Das erste Dokument enthält die Felder Adresse und dob die im zweiten Dokument nicht vorhanden sind, während das zweite Dokument Felder enthält Geschlecht und Besetzung welche im ersten nicht vorhanden sind. Stellen Sie sich vor, wenn wir dieses Ding in SQL entworfen hätten, hätten wir vier zusätzliche Spalten für Adresse, dob, Geschlecht und Besetzung, Einige davon würden leere Werte (oder Nullwerte) speichern und somit unnötigen Speicherplatz belegen.
Dieses Modell eines dynamischen Schemas ist der Grund, warum NosSQL-Datenbanken in Bezug auf das Design sehr skalierbar sind. Verschiedene komplexe Schemas (hierarchisch, baumstrukturiert usw.), für die eine Anzahl von RDBMS-Tabellen erforderlich wäre, können unter Verwendung solcher Dokumente effizient entworfen werden. Ein typisches Beispiel wäre das Speichern von Benutzerbeiträgen, deren Vorlieben, Kommentaren und anderen zugehörigen Informationen in Form von Dokumenten. Eine SQL-Implementierung für dasselbe hätte idealerweise separate Tabellen zum Speichern von Beiträgen, Kommentaren und Likes, während ein MongoDB-Dokument all diese Informationen in einem einzigen Dokument speichern kann.
Beziehungen in RDBMS werden mithilfe von Primär- und Fremdschlüsselbeziehungen und deren Abfrage mithilfe von Joins erzielt. In MongoDB gibt es kein derart unkompliziertes Mapping, aber die Beziehungen werden hier mithilfe von eingebetteten und verknüpften Dokumenten erstellt.
Betrachten wir ein Beispiel, in dem wir Benutzerinformationen und entsprechende Kontaktinformationen speichern müssen. Ein ideales SQL-Design hätte beispielsweise zwei Tabellen Nutzerinformation und Kontaktinformation, mit Primärschlüsseln Ich würde und contact_id wie in Abb. 3 dargestellt Kontaktinformation Tabelle würde auch eine Spalte enthalten Benutzeridentifikation Welches wäre der Fremdschlüssel, der mit dem Ich würde Feld der Nutzerinformation Tabelle.
Jetzt werden wir sehen, wie wir solche Beziehungen in MongoDB unter Verwendung von Ansätzen für das Verknüpfen von Dokumenten und eingebetteten Dokumenten entwerfen. Beachten Sie, dass wir im SQL-Schema im Allgemeinen eine Spalte hinzufügen (z. B. Ich würde und contact_id in unserem Fall), die als primäre Spalte für diese Tabelle dient. In MongoDB wird jedoch im Allgemeinen das automatisch generierte verwendet _Ich würde Feld als Primärschlüssel, um die Dokumente eindeutig zu identifizieren.
Dieser Ansatz verwendet zwei Sammlungen, Nutzerinformation und Kontaktinformation beide haben ihre Einzigartigkeit _Ich würde Felder. Wir werden ein Feld haben Benutzeridentifikation in dem Kontaktinformation Dokument, das sich auf die _Ich würde Feld der Nutzerinformation Dokument, das angibt, welchem Benutzer der Kontakt entspricht. (Siehe Abb. 4) Beachten Sie, dass in MongoDB die Beziehungen und die entsprechenden Operationen manuell (z. B. durch Code) erledigt werden müssen, da keine Fremdschlüsseleinschränkungen und -regeln gelten.
Das Benutzeridentifikation Feld in unserem Dokument ist einfach ein Feld, das einige Daten enthält, und die gesamte damit verbundene Logik muss von uns implementiert werden. Zum Beispiel, auch wenn Sie einige einfügen Benutzeridentifikation in dem Kontaktinformation Dokument, das in der nicht vorhanden ist Nutzerinformation Sammlung, MongoDB wird keine Fehlermeldung ausgeben, die dies sagt Benutzeridentifikation wurde nicht im gefunden Nutzerinformation collection (im Gegensatz zu SQL, wo dies eine ungültige Fremdschlüsseleinschränkung wäre).
Der zweite Ansatz ist die Einbettung der Kontaktinformation Dokument in der Nutzerinformation Dokument wie folgt (Abb. 5):
Im obigen Beispiel haben wir ein kleines Dokument mit Kontaktinformationen in die Benutzerinformationen eingebettet. Auf ähnliche Weise können große komplexe Dokumente und hierarchische Daten auf diese Weise eingebettet werden, um Entitäten zu verknüpfen.
Welcher Ansatz zwischen dem Linking- und dem Embedded-Ansatz zu verwenden ist, hängt vom jeweiligen Szenario ab. Wenn zu erwarten ist, dass die Daten, die eingebettet werden sollen, größer werden, ist es besser, den Linking-Ansatz als den Embedded-Ansatz zu verwenden, um zu vermeiden, dass das Dokument zu groß wird. Der eingebettete Ansatz wird im Allgemeinen in Fällen verwendet, in denen eine begrenzte Informationsmenge (wie in unserem Beispiel die Adresse) eingebettet werden muss.
Zusammenfassend stellt das folgende Diagramm (Abb. 6) die von uns diskutierten gemeinsamen Zusammenhänge dar:
Nun, da wir mit den grundlegenden Zuordnungen zwischen RDBMS und MongoDB vertraut sind, werden wir diskutieren, wie sich die für die Interaktion mit der Datenbank verwendete Abfragesprache unterscheidet.
Nehmen wir für MongoDB-Abfragen eine Sammlung an Benutzer mit Dokumentstruktur wie folgt:
"_id": ObjectId ("5146bb52d8524270060001f3"), "post_text": "Dies ist ein Beispielpost", "user_name": "mark", "post_privacy": "public", "post_likes_count": 0 Für SQL-Abfragen nehmen wir die Tabelle an Benutzer fünf Spalten mit folgender Struktur haben:
Wir werden Fragen zum Erstellen und Ändern von Sammlungen (oder Tabellen) sowie zum Einfügen, Lesen, Aktualisieren und Entfernen von Dokumenten (oder Zeilen) besprechen. Für jeden Punkt gibt es zwei Abfragen, eine für SQL und eine andere für MongoDB. Ich werde die MongoDB-Abfragen nur erklären, da wir mit den SQL-Abfragen ziemlich vertraut sind. Die hier dargestellten MongoDB-Abfragen werden in der Mongo-JavaScript-Shell geschrieben, während die SQL-Abfragen in MySQL geschrieben werden.
In MongoDB muss die Auflistungsstruktur nicht explizit erstellt werden (wie bei Tabellen, die a verwenden.) TABELLE ERSTELLEN Abfrage). Die Struktur des Dokuments wird automatisch erstellt, wenn die erste Einfügung in der Sammlung erfolgt. Sie können jedoch eine leere Sammlung mit erstellen createCollection Befehl.
SQL: CREATE TABLE 'posts' ('id' int (11) NOT NULL AUTO_INCREMENT, 'post_text' varchar (500) NOT NULL, 'benutzername' varchar (20) NOT NULL, 'post_privacy' varchar (10) NOT NULL, ' post_likes_count 'int (11) NOT NULL, PRIMARY KEY (' id ')) MongoDB: db.createCollection ("posts") Um ein Dokument in MongoDB einzufügen, verwenden wir die einfügen Methode, die ein Objekt mit Schlüsselwertpaaren als Eingabe verwendet. Das eingefügte Dokument enthält das automatisch generierte Dokument _Ich würde Feld. Sie können jedoch auch explizit einen 12-Byte-Wert als angeben _Ich würde zusammen mit den anderen Feldern.
SQL: INSERT INTO 'posts' ('id', 'post_text', 'user_name', 'post_privacy', 'post_likes_count')) VALUES (NULL, 'Dies ist ein Beispielpost', 'mark', 'public', '0 '); MongoDB: db.posts.insert (user_name: "mark", post_text: "Dies ist ein Beispielpost", post_privacy: "public", post_likes_count: 0) Es gibt kein Tabelle ändern Funktion in MongoDB, um die Dokumentstruktur zu ändern. Da die Dokumente im Schema dynamisch sind, ändert sich das Schema, sobald das Dokument aktualisiert wird.
MongoDB verwendet die finden Methode, die dem entspricht WÄHLEN Befehl in SQL. Die folgenden Anweisungen lesen einfach alle Dokumente aus der Beiträge Sammlung.
SQL: SELECT * FROM 'Beiträge' MongoDB: db.posts.find ()
Die folgende Abfrage führt eine bedingte Suche nach Dokumenten mit Nutzername Feld als Kennzeichen. Alle Kriterien zum Abrufen der Dokumente müssen in die ersten Klammern durch Kommas getrennt angegeben werden.
SQL: SELECT * FROM 'post' WHERE 'user_name' = 'mark' MongoDB: db.posts.find (user_name: "mark")
Die folgende Abfrage ruft bestimmte Spalten ab, post_text und post_likes_count wie in den zweiten Klammern angegeben.
SQL: SELECT 'post_text', 'post_likes_count' FROM 'Beiträge' MongoDB: db.posts.find (, post_text: 1, post_likes_count: 1)
Beachten Sie, dass MongoDB standardmäßig das zurückgibt _Ich würde Feld mit jeder find-Anweisung. Wenn wir dieses Feld nicht in unserer Ergebnismenge haben möchten, müssen wir das angeben _Ich würde Schlüssel mit einem 0 Wert in der Liste der abzurufenden Spalten. Das 0 Der Wert des Schlüssels zeigt an, dass wir dieses Feld aus der Ergebnismenge ausschließen möchten.
MongoDB: db.posts.find (, post_text: 1, post_likes_count: 1, _id: 0)
Die folgende Abfrage ruft bestimmte Felder basierend auf den Kriterien ab Nutzername ist Kennzeichen.
SQL: SELECT 'post_text', 'post_likes_count' FROM 'post' WHERE 'user_name' = 'mark' MongoDB: db.posts.find (benutzername: "mark", post_text: 1, post_likes_count: 1)
Wir werden nun ein weiteres Kriterium hinzufügen, um die Beiträge mit dem Datenschutz als öffentlich zu erhalten. Die mit Kommas angegebenen Kriterienfelder repräsentieren die logische UND Bedingung. Daher sucht diese Anweisung nach Dokumenten mit beidem Nutzername wie Kennzeichen und post_privacy wie Öffentlichkeit.
SQL: SELECT 'post_text', 'post_likes_count' FROM 'post' WHERE 'user_name' = 'mark' AND 'post_privacy' = 'public' MongoDB: db.posts.find (benutzername: "mark", post_privacy: "public") , post_text: 1, post_likes_count: 1)
Um logisch zu verwenden ODER zwischen den Kriterien in der finden Methode verwenden wir die $ oder Operator.
SQL: SELECT 'post_text', 'post_likes_count' FROM 'post' WHERE 'user_name' = 'mark' ODER 'post_privacy' = 'public' MongoDB: db.posts.find ($ oder: [user_name: "mark") , post_privacy: "public"], post_text: 1, post_likes_count: 1)
Als nächstes verwenden wir die Sortieren Methode, die das Ergebnis in aufsteigender Reihenfolge von sortiert post_likes_count(angezeigt durch 1).
SQL: SELECT * FROM 'posts' WHERE 'user_name' = 'mark' Reihenfolge nach post_likes_count ASC MongoDB: db.posts.find (user_name: "mark"). Sort (post_likes_count: 1)
Um die Ergebnisse in absteigender Reihenfolge zu sortieren, geben wir an -1 als Wert des Feldes.
SQL: SELECT * FROM 'posts' WHERE 'user_name' = 'mark' Reihenfolge nach post_likes_count DESC MongoDB: db.posts.find (user_name: "mark"). Sort (post_likes_count: -1)
Um die Anzahl der zurückzusendenden Dokumente zu begrenzen, verwenden wir die Grenze Methode zur Angabe der Anzahl der Dokumente.
SQL: SELECT * FROM 'posts' LIMIT 10 MongoDB: db.posts.find (). Limit (10)
Die Art, wie wir es benutzen Versatz In SQL verwenden wir einige Datensätze, die wir überspringen überspringen Funktion in MongoDB. Die folgende Anweisung würde beispielsweise zehn Beiträge abrufen, wobei die ersten fünf übersprungen werden.
SQL: SELECT * FROM 'posts' LIMIT 10 OFFSET 5 MongoDB: db.posts.find (). Limit (10) .skip (5)
Der erste Parameter zum aktualisieren Methode gibt die Kriterien für die Auswahl der Dokumente an. Der zweite Parameter gibt den tatsächlich durchzuführenden Aktualisierungsvorgang an. Die folgende Abfrage wählt beispielsweise alle Dokumente mit aus Nutzername wie Kennzeichen und setzt ihre post_privacy wie Privatgelände.
Ein Unterschied ist hier standardmäßig MongoDB aktualisieren Abfrage aktualisiert nur ein Dokument (und das erste übereinstimmende) Dokument. Um alle übereinstimmenden Dokumente zu aktualisieren, müssen Sie einen dritten Parameter angeben multi wie wahr zeigt an, dass wir mehrere Dokumente aktualisieren möchten.
SQL: UPDATE veröffentlicht SET post_privacy = "private" WHERE user_name = "mark" MongoDB: db.posts.update (user_name: "mark", $ set: post_privacy: "private", multi: true )
Das Entfernen von Dokumenten ist ziemlich einfach und ähnelt SQL.
SQL: DELETE FROM Beiträge WHERE user_name = "mark" MongoDB: db.posts.remove (user_name: "mark")
MongoDB hat einen Standardindex für die _Ich würde Feld jeder Sammlung. Um neue Indizes für die Felder zu erstellen, verwenden wir sichertIndex Methode, die die Felder und die zugehörige Sortierreihenfolge angibt 1 oder -1(aufsteigend oder absteigend).
SQL: CREATE INDEX index_posts ON-Posts (Benutzername, post_likes_count DESC) MongoDB: db.posts.ensureIndex (benutzername: 1, post_likes_count: -1)
Um alle in einer Sammlung vorhandenen Indizes anzuzeigen, verwenden wir getIndexes Methode in den gleichen Zeilen von INDEX ANZEIGEN Abfrage von SQL.
SQL: SHOW INDEX FROM Beiträge MongoDB: db.posts.getIndexes ()
In diesem Artikel haben wir verstanden, wie die elementaren Konzepte und Begriffe von RDBMS / SQL in MongoDB zusammenhängen. Wir haben uns mit dem Entwerfen von Beziehungen in MongoDB beschäftigt und erfahren, wie die Funktionalität der grundlegenden SQL-Abfragen in MongoDB abbildet.
Nachdem Sie sich einen ersten Überblick über diesen Artikel verschafft haben, können Sie komplexe Abfragen ausprobieren, darunter Aggregation, Kartenreduzierung und Abfragen, die mehrere Sammlungen betreffen. Sie können auch einige Online-Tools verwenden, um SQL-Abfragen zu Beginn in MongoDB-Abfragen zu konvertieren. Sie können selbst ein Beispiel für ein MongoDB-Datenbankschema entwerfen. Eines der besten Beispiele wäre eine Datenbank, in der Benutzerbeiträge, Likes, Kommentare und Likes gespeichert werden. Dies gibt Ihnen einen praktischen Überblick über das flexible Schema-Design, das MongoDB bietet.
Fühlen Sie sich frei, um Vorschläge, Fragen oder Ideen zu kommentieren, die Sie gerne weiter sehen möchten.
