Verwenden von Verbindungen in MongoDB -NoSQL -Datenbanken

Kernpunkte

• mongoDB, eine NoSQL-Datenbank, führte einen neuen $lookup -Operator in Version 3.2 ein, der an zwei oder mehr Sätzen linksgerichtete Operationen ausführen kann, wodurch Daten ähnlich wie relationale Datenbanken erfolgen. Dieser Betreiber ist jedoch darauf beschränkt, in aggregierten Operationen zu verwenden, die komplexer und normalerweise langsamer sind als einfache Nachschlaganfragen.
• mongoDBs $lookup -Operator benötigt vier Parameter: localField (geben Sie das Suchfeld im Dokument ein), from (die Sammlung, die angeschlossen werden soll), foreignField (Felder, die in der Sammlung von from) und as (Name des Ausgabefeldes). Dieser Bediener kann in aggregierten Abfragen verwendet werden, um Beiträge abzustimmen, in der Reihenfolge zu sortieren, die Anzahl der Elemente zu begrenzen, Benutzerdaten zu verbinden, Benutzerarrays abzuflachen und nur die erforderlichen Felder zurückzugeben.
• Obwohl der $lookup -Preiber von MongoDB nützlich ist und eine kleine Menge an relationalen Daten in einer NoSQL -Datenbank verwalten kann, ist dies kein Ersatz für die leistungsstärkere Join -Klausel in SQL. Wenn das Benutzerdokument in MongoDB gelöscht wird, wird das Orphan Post -Dokument erhalten, was auf einen Mangel an Einschränkungen hinweist. Wenn der $lookup -Operator häufig verwendet wird, kann dies daher angeben, dass die falsche Datenspeicherung verwendet wird und eine relationale (SQL) -Datenbank möglicherweise besser geeignet ist.

Vielen Dank an Julian Motz für seine Peer Review -Hilfe.

---

Einer der größten Unterschiede zwischen den SQL- und NoSQL -Datenbanken ist die Verbindung. In einer relationalen Datenbank können Sie mit der SQL -Join -Klausel Zeilen aus zwei oder mehr Tabellen mit einem gemeinsamen Feld zwischen ihnen kombinieren. Wenn Sie beispielsweise eine Buch- und Verlagstabelle haben, können Sie den folgenden SQL -Befehl schreiben:

SELECT book.title, publisher.name
FROM book
LEFT JOIN book.publisher_id ON publisher.id;

Mit anderen Worten, in der Buchentabelle enthält ein Feld publisher_id, das das Feld ID in der Publisher -Tabelle verweist.

Dies ist praktisch, da ein einzelner Verlag Tausende von Büchern bereitstellen kann. Wenn wir die Details des Herausgebers in Zukunft aktualisieren müssen, können wir den einzelnen Datensatz ändern. Die Datenreduktion wird minimiert, da wir die Informationen des Verlags für jedes Buch nicht wiederholen müssen. Diese Technologie wird als Standardisierung bezeichnet.

SQL -Datenbanken bieten eine Reihe von Standardisierung und Einschränkungen, um die Aufrechterhaltung von Beziehungen sicherzustellen.

noSql == Kein Join?

Dies ist nicht immer der Fall…

dokumentorientierte Datenbanken (z. B. MongoDB) sind so ausgelegt, dass sie de-armalisierte Daten speichern. Im Idealfall sollte es keine Beziehung zwischen Sätzen geben. Wenn dieselben Daten in zwei oder mehr Dokumenten enthalten sind, muss diese wiederholt werden.

Dies kann frustrierend sein, da es fast keine Situation gibt, in der Sie niemals relationale Daten benötigen. Glücklicherweise führte MongoDB 3.2 einen neuen -Operator ein, der bei zwei oder mehr Sätzen linksgerichtete Operationen ausführen kann. Aber es gibt ein Problem ... $lookup

MongoDB -Aggregation

$lookup erlaubt nur in aggregierten Operationen verwendet werden. Stellen Sie sich dies als eine Pipeline einer Reihe von Operatoren vor, die die Ergebnisse von Abfragen, Filtern und Gruppen abfragen, gefiltert. Die Ausgabe eines Operators wird als Eingang für den nächsten Bediener verwendet.

Aggregationen sind schwerer zu verstehen als einfache Suchabfragen und laufen normalerweise langsamer. Sie sind jedoch leistungsstark und eine wertvolle Option für komplexe Suchvorgänge.

Es ist am besten, ein Beispiel zu verwenden, um die Aggregation zu erklären. Angenommen, wir erstellen eine Social -Media -Plattform mit einer Sammlung von Benutzern. Es speichert die Details jedes Benutzers in einem separaten Dokument. Zum Beispiel:

SELECT book.title, publisher.name
FROM book
LEFT JOIN book.publisher_id ON publisher.id;

Wir können so viele Felder hinzufügen, wie wir es wollen, aber alle MongoDB -Dokumente erfordern ein _id -Feld mit einem eindeutigen Wert. _id Ähnlich wie bei SQL Primärschlüssel werden sie bei Bedarf automatisch eingefügt.

Unser soziales Netzwerk benötigt jetzt eine Sammlung von Beiträgen, in denen eine große Anzahl aufschlussreicher Updates von Benutzern gespeichert wird. Das Dokument speichert Text, Datum, Bewertung und Verweise auf den Benutzer, der ihn im Feld user_id geschrieben hat:

{
  "_id": ObjectID("45b83bda421238c76f5c1969"),
  "name": "User One",
  "email": "userone@email.com",
  "country": "UK",
  "dob": ISODate("1999-09-13T00:00:00.000Z")
}

Wir möchten jetzt die letzten zwanzig Beiträge anzeigen, die von allen Benutzern in umgekehrter Reihenfolge bewertet werden. Jedes zurückgegebene Dokument sollte Text, die Zeit des Beitrags sowie den Namen und das Land des zugehörigen Benutzers enthalten.

MongoDB -Aggregation -Abfrage besteht aus einer Reihe von Pipeline -Operatoren, die jede Operation in der Reihenfolge definieren. Zunächst müssen wir den $match -Filter verwenden, um alle Dokumente mit korrekten Bewertungen aus der Postsammlung zu extrahieren:

{
  "_id": ObjectID("17c9812acff9ac0bba018cc1"),
  "user_id": ObjectID("45b83bda421238c76f5c1969"),
  "date": ISODate("2016-09-05T03:05:00.123Z"),
  "text": "My life story so far",
  "rating": "important"
}

Wir müssen jetzt die passenden Elemente in umgekehrter Reihenfolge sortieren, indem wir den Operator $sort verwenden:

{ "$match": { "rating": "important" } }

Da wir nur zwanzig Beiträge benötigen, können wir die $limit -Pufe anwenden, damit MongoDB nur die gewünschten Daten verarbeiten muss:

{ "$sort": { "date": -1 } }

Wir können jetzt den neuen $lookup Bediener verwenden, um Daten aus der Benutzersammlung zu verbinden. Es erfordert ein Objekt mit vier Parametern:

• localField: Geben Sie das Suchfeld in das Dokument
ein
• from: Sammlung, die angeschlossen werden kann
• foreignField: Felder in from Sammlung
gefunden
• as: Der Name des Ausgabebuchs.

Daher ist unser Bediener:

{ "$limit": 20 }

Dies erstellt ein neues Feld in unserer Ausgabe namens userinfo. Es enthält ein Array, in dem jeder Wert dem Benutzerdokument übereinstimmt:

{ "$lookup": {
  "localField": "user_id",
  "from": "user",
  "foreignField": "_id",
  "as": "userinfo"
} }

Wir haben eine Eins-zu-Eins-Beziehung post.user_id und user._id, da ein Beitrag nur einen Autor haben kann. Daher enthält unser userinfo -Array immer nur ein Element. Wir können den $unwind -Operator verwenden, um ihn in ein Subdokument zu zerlegen:

"userinfo": [
  { "name": "User One", ... }
]

Ausgabe wird nun in ein praktischere Format umgewandelt, wobei andere Betreiber zur Bewerbung verfügbar sind:

{ "$unwind": "$userinfo" }

Schließlich können wir die $project -Püche in der Pipeline verwenden, um Text, Zeit des Posts, den Namen und das Land des Benutzers zurückzugeben:

SELECT book.title, publisher.name
FROM book
LEFT JOIN book.publisher_id ON publisher.id;

alles zusammenfügen

Unsere endgültige aggregierte Abfrage entspricht den Beiträgen, Sortierungen, Grenzen für die neuesten zwanzig Elemente, verbindet Benutzerdaten, flacht Benutzerarrays und gibt nur die erforderlichen Felder zurück. Vollständiger Befehl:

{
  "_id": ObjectID("45b83bda421238c76f5c1969"),
  "name": "User One",
  "email": "userone@email.com",
  "country": "UK",
  "dob": ISODate("1999-09-13T00:00:00.000Z")
}

Das Ergebnis ist eine Sammlung von bis zu zwanzig Dokumenten. Zum Beispiel:

{
  "_id": ObjectID("17c9812acff9ac0bba018cc1"),
  "user_id": ObjectID("45b83bda421238c76f5c1969"),
  "date": ISODate("2016-09-05T03:05:00.123Z"),
  "text": "My life story so far",
  "rating": "important"
}

Großartig! Ich kann endlich zu NoSQL wechseln!

mongoDB $lookup ist nützlich und mächtig, aber selbst dieses grundlegende Beispiel erfordert eine komplexe Aggregationsabfrage. Es kann die leistungsstärkere Join -Klausel in SQL nicht ersetzen. MongoDB liefert auch keine Einschränkungen.

im Idealfall sollte der $lookup -Operator selten benötigt werden. Wenn Sie es häufig benötigen, haben Sie möglicherweise den falschen Datenspeicher verwendet ...

Wenn Sie relationale Daten haben, verwenden Sie bitte eine SQL -Datenbank (Relational (SQL)!

Das heißt $lookup ist eine beliebte Ergänzung zu MongoDB 3.2. Es überwindet einige der frustrierenderen Probleme bei der Verwendung einer kleinen Menge an relationalen Daten in einer NoSQL -Datenbank.

FAQs über die Verwendung von Join in MongoDB -NoSQL -Datenbanken (FAQ)

Was ist der Unterschied zwischen SQL -Verbindung und MongoDB -Verbindung?

In einer SQL -Datenbank kombiniert der Verbindungsvorgang Zeilen aus zwei oder mehr Tabellen basierend auf den zwischen ihnen verbundenen Spalten. MongoDB als NoSQL -Datenbank unterstützt jedoch keine herkömmlichen SQL -Verbindungen. Stattdessen bietet MongoDB zwei Möglichkeiten, ähnliche Operationen auszuführen: die $lookup Stufe und die $graphLookup -Präparation in der Aggregation. Mit diesen Methoden können Sie Daten aus mehreren Sammlungen zu einem einzigen Ergebnissatz kombinieren.

Wie funktioniert die

-Stufe in MongoDB? $lookup Mit der

mit der

-Püche in mongoDB können Sie Dokumente aus einer anderen Sammlung ("Connected" -Kollektion) anschließen und die angeschlossenen Dokumente in das Eingabedokument hinzufügen. Die $lookup -Phase gibt die "aus" Sammlung, "Localfield" und "Foreignfield" an, um das Dokument zu entsprechen, und das "als" Feld ", um das Dokument auszugeben. Es ähnelt dem linken äußeren Join in SQL, wobei alle Dokumente aus der Eingabetaste zurückgegeben und Dokumente aus der "From" -Kollektion übereinstimmen. $lookup

Kann ich eine rekursive Suche mit der MongoDB -Verbindung durchführen?

Ja, MongoDB liefert eine

-Phase für die rekursive Suche. Die $graphLookup -Stufe führt eine rekursive Suche im angegebenen Satz durch und kann die Tiefe und Breite der Suche einschränken. Es ist nützlich, um hierarchische Daten oder Diagramme abzufragen, bei denen die Anzahl der Ebenen unbekannt ist oder sich ändern kann. $graphLookup

Wie optimieren Sie die Leistung, wenn Sie die MongoDB -Verbindung verwenden?

Um die Leistung bei der Verwendung von MongoDB -Verbindungen zu optimieren, berücksichtigen Sie die folgenden Strategien: Verwenden Sie die Indizes für "Lokalfeld" und "Fremdfeld", um den Übereinstimmungsprozess zu beschleunigen. 🎜> Stufe

und $lookup Stufen zum Filtern und Umwandeln von Dokumenten. $match

Kann ich mehrere Sammlungen in MongoDB anschließen?

Ja, Sie können mehrere MongoDB -Sammlungen anschließen, indem Sie mehrere $lookup Stufen in einer Aggregationspipeline verknüpfen. Jede $lookup -Püche fügt verbundene Dokumente aus einer anderen Sammlung zum Eingabedokument hinzu.

Wie kann man mit Null- oder fehlenden Werten umgehen, wenn die MongoDB -Verbindung verwendet wird?

Bei Verwendung der MongoDB -Verbindung fügt die $lookup -Phase das Dokument in der "From" -Kollektion nicht übereinstimmt, wenn das Dokument in der Eingabesammlung nicht übereinstimmt, ein leeres Array zum Feld "AS". Sie können diese Null- oder fehlenden Werte verarbeiten, indem Sie die $lookup -Phase nach der $match -Phase hinzufügen, um Dokumente mit leeren "als" Felder herauszufiltern.

Kann ich die MongoDB -Verbindung mit Sharded -Sammlungen verwenden?

Ausgehend von MongoDB 3.6 können die Stufen $lookup und $graphLookup Sharded -Sets von "aus" -Sets sein. Aufgrund des zusätzlichen Netzwerkaufwands ist jedoch möglicherweise nicht so gut wie nicht geschützte Sammlungen.

Wie sortiere ich verbundene Dokumente in MongoDB?

Sie können verbundene Dokumente in MongoDB sortieren, indem Sie die $lookup -Phase nach der $sort -Phase in der Aggregationspipeline hinzufügen. Die $sort -Püche sortiert die Dokumente im angegebenen Feld in aufsteigender oder absteigender Reihenfolge.

Kann ich die MongoDB -Verbindung mit find() Methode verwenden?

Nein, MongoDB -Verbindung kann nicht mit find() Methode verwendet werden. Die Stufen $lookup und $graphLookup sind Teil des Aggregations -Frameworks, das fortschrittlichere Datenverarbeitungsfunktionen bietet als die find() -Methode.

Wie debugge oder Fehlerbehebung MongoDB -Verbindungsfehler?

Um MongoDB -Verbindungsfehler zu debuggen oder zu beheben, können Sie die Methode explain() verwenden, um den Ausführungsplan der Aggregat -Pipeline zu analysieren. Die explain() -Methode enthält detaillierte Informationen zur Bühne, einschließlich der Anzahl der verarbeiteten Dokumente, der verbrauchten Zeit und der Verwendung des Index.

Das obige ist der detaillierte Inhalt vonVerwenden von Verbindungen in MongoDB -NoSQL -Datenbanken. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!