MongoDB - Kurzanleitung

MongoDB ist eine plattformübergreifende, dokumentenorientierte Datenbank, die hohe Leistung, hohe Verfügbarkeit und einfache Skalierbarkeit bietet. MongoDB arbeitet am Konzept der Sammlung und des Dokuments.

Datenbank

Die Datenbank ist ein physischer Container für Sammlungen. Jede Datenbank erhält ihre eigenen Dateien im Dateisystem. Ein einzelner MongoDB-Server verfügt normalerweise über mehrere Datenbanken.

Sammlung

Die Sammlung ist eine Gruppe von MongoDB-Dokumenten. Dies entspricht einer RDBMS-Tabelle. Eine Sammlung existiert in einer einzelnen Datenbank. Sammlungen erzwingen kein Schema. Dokumente innerhalb einer Sammlung können unterschiedliche Felder haben. In der Regel haben alle Dokumente in einer Sammlung einen ähnlichen oder verwandten Zweck.

Dokument

Ein Dokument besteht aus einer Reihe von Schlüssel-Wert-Paaren. Dokumente haben ein dynamisches Schema. Dynamisches Schema bedeutet, dass Dokumente in derselben Sammlung nicht denselben Satz von Feldern oder dieselbe Struktur haben müssen und dass gemeinsame Felder in den Dokumenten einer Sammlung unterschiedliche Datentypen enthalten können.

Die folgende Tabelle zeigt die Beziehung der RDBMS-Terminologie zu MongoDB.

RDBMS MongoDB
Datenbank Datenbank
Tabelle Sammlung
Tupel / Reihe Dokument
Säule Feld
Table Join Eingebettete Dokumente
Primärschlüssel Primärschlüssel (Standardschlüssel _id von mongodb selbst bereitgestellt)
Datenbankserver und Client
Mysqld / Oracle Mongod
mysql / sqlplus Mongo

Beispieldokument

Das folgende Beispiel zeigt die Dokumentstruktur einer Blog-Site, bei der es sich lediglich um ein durch Kommas getrenntes Schlüsselwertpaar handelt.

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100, 
   comments: [	
      {
         user:'user1',
         message: 'My first comment',
         dateCreated: new Date(2011,1,20,2,15),
         like: 0 
      },
      {
         user:'user2',
         message: 'My second comments',
         dateCreated: new Date(2011,1,25,7,45),
         like: 5
      }
   ]
}

_idist eine hexadezimale Zahl von 12 Byte, die die Eindeutigkeit jedes Dokuments sicherstellt. Sie können _id beim Einfügen des Dokuments angeben. Wenn Sie dies nicht angeben, stellt MongoDB für jedes Dokument eine eindeutige ID bereit. Diese 12 Bytes, die ersten 4 Bytes für den aktuellen Zeitstempel, die nächsten 3 Bytes für die Maschinen-ID, die nächsten 2 Bytes für die Prozess-ID des MongoDB-Servers und die verbleibenden 3 Bytes sind einfache inkrementelle VALUE.

Jede relationale Datenbank verfügt über ein typisches Schemadesign, das die Anzahl der Tabellen und die Beziehung zwischen diesen Tabellen anzeigt. In MongoDB gibt es kein Konzept für eine Beziehung.

Vorteile von MongoDB gegenüber RDBMS

  • Schema less- MongoDB ist eine Dokumentendatenbank, in der eine Sammlung unterschiedliche Dokumente enthält. Anzahl der Felder, Inhalt und Größe des Dokuments können von Dokument zu Dokument unterschiedlich sein.

  • Die Struktur eines einzelnen Objekts ist klar.

  • Keine komplexen Verknüpfungen.

  • Tiefe Abfragefähigkeit. MongoDB unterstützt dynamische Abfragen von Dokumenten mithilfe einer dokumentbasierten Abfragesprache, die fast so leistungsfähig ist wie SQL.

  • Tuning.

  • Ease of scale-out - MongoDB ist einfach zu skalieren.

  • Konvertierung / Zuordnung von Anwendungsobjekten zu Datenbankobjekten nicht erforderlich.

  • Verwendet internen Speicher zum Speichern des (mit Fenstern versehenen) Arbeitssatzes, um einen schnelleren Zugriff auf Daten zu ermöglichen.

Warum MongoDB verwenden?

  • Document Oriented Storage - Daten werden in Form von Dokumenten im JSON-Stil gespeichert.

  • Index für ein beliebiges Attribut

  • Replikation und hohe Verfügbarkeit

  • Auto-sharding

  • Reichhaltige Fragen

  • Schnelle Updates vor Ort

  • Professionelle Unterstützung durch MongoDB

Wo kann man MongoDB verwenden?

  • Große Daten
  • Content Management und Lieferung
  • Mobile und soziale Infrastruktur
  • Benutzerdatenverwaltung
  • Data Hub

Lassen Sie uns nun sehen, wie MongoDB unter Windows installiert wird.

Installieren Sie MongoDB unter Windows

Um MongoDB unter Windows zu installieren, laden Sie zuerst die neueste Version von MongoDB von herunter https://www.mongodb.org/downloads. Stellen Sie sicher, dass Sie abhängig von Ihrer Windows-Version die richtige Version von MongoDB erhalten. Um Ihre Windows-Version zu erhalten, öffnen Sie die Eingabeaufforderung und führen Sie den folgenden Befehl aus.

C:\>wmic os get osarchitecture
OSArchitecture
64-bit
C:\>

32-Bit-Versionen von MongoDB unterstützen nur Datenbanken mit weniger als 2 GB und sind nur für Test- und Evaluierungszwecke geeignet.

Extrahieren Sie nun Ihre heruntergeladene Datei nach c: \ drive oder an einen anderen Speicherort. Stellen Sie sicher, dass der Name des extrahierten Ordners mongodb-win32-i386- [version] oder mongodb-win32-x86_64- [version] lautet. Hier ist [Version] die Version des MongoDB-Downloads.

Öffnen Sie als Nächstes die Eingabeaufforderung und führen Sie den folgenden Befehl aus.

C:\>move mongodb-win64-* mongodb
   1 dir(s) moved.
C:\>

Wenn Sie die MongoDB an einem anderen Ort extrahiert haben, gehen Sie mit dem Befehl zu diesem Pfad cd FOLDER/DIR und führen Sie nun den oben angegebenen Prozess aus.

MongoDB benötigt einen Datenordner zum Speichern seiner Dateien. Der Standardspeicherort für das MongoDB-Datenverzeichnis ist c: \ data \ db. Sie müssen diesen Ordner also über die Eingabeaufforderung erstellen. Führen Sie die folgende Befehlssequenz aus.

C:\>md data
C:\md data\db

Wenn Sie die MongoDB an einem anderen Speicherort installieren müssen, müssen Sie einen alternativen Pfad für angeben \data\db durch Einstellen des Pfades dbpath im mongod.exe. Geben Sie dazu die folgenden Befehle aus.

Navigieren Sie an der Eingabeaufforderung zu dem Verzeichnis bin, das sich im MongoDB-Installationsordner befindet. Angenommen, mein Installationsordner istD:\set up\mongodb

C:\Users\XYZ>d:
D:\>cd "set up"
D:\set up>cd mongodb
D:\set up\mongodb>cd bin
D:\set up\mongodb\bin>mongod.exe --dbpath "d:\set up\mongodb\data"

Dies wird zeigen waiting for connections Meldung in der Konsolenausgabe, die angibt, dass der Prozess mongod.exe erfolgreich ausgeführt wird.

Um die MongoDB auszuführen, müssen Sie eine weitere Eingabeaufforderung öffnen und den folgenden Befehl ausführen.

D:\set up\mongodb\bin>mongo.exe
MongoDB shell version: 2.4.6
connecting to: test
>db.test.save( { a: 1 } )
>db.test.find()
{ "_id" : ObjectId(5879b0f65a56a454), "a" : 1 }
>

Dies zeigt, dass MongoDB erfolgreich installiert und ausgeführt wird. Wenn Sie das nächste Mal MongoDB ausführen, müssen Sie nur Befehle ausgeben.

D:\set up\mongodb\bin>mongod.exe --dbpath "d:\set up\mongodb\data" 
D:\set up\mongodb\bin>mongo.exe

Installieren Sie MongoDB unter Ubuntu

Führen Sie den folgenden Befehl aus, um den öffentlichen GPG-Schlüssel von MongoDB zu importieren:

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10

Erstellen Sie mit dem folgenden Befehl eine Datei /etc/apt/sources.list.d/mongodb.list.

echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' 
   | sudo tee /etc/apt/sources.list.d/mongodb.list

Geben Sie nun den folgenden Befehl ein, um das Repository zu aktualisieren:

sudo apt-get update

Installieren Sie als nächstes die MongoDB mit dem folgenden Befehl:

apt-get install mongodb-10gen = 2.2.3

In der obigen Installation ist 2.2.3 derzeit die MongoDB-Version. Stellen Sie sicher, dass Sie immer die neueste Version installieren. Jetzt ist MongoDB erfolgreich installiert.

Starten Sie MongoDB

sudo service mongodb start

Stoppen Sie MongoDB

sudo service mongodb stop

Starten Sie MongoDB neu

sudo service mongodb restart

Führen Sie den folgenden Befehl aus, um MongoDB zu verwenden.

mongo

Dadurch werden Sie mit der Ausführung der MongoDB-Instanz verbunden.

MongoDB-Hilfe

Geben Sie ein, um eine Liste der Befehle zu erhalten db.help()im MongoDB-Client. Dadurch erhalten Sie eine Liste der Befehle, wie im folgenden Screenshot gezeigt.

MongoDB-Statistiken

Geben Sie den Befehl ein, um Statistiken zum MongoDB-Server abzurufen db.stats()im MongoDB-Client. Dies zeigt den Datenbanknamen, die Anzahl der Sammlungen und Dokumente in der Datenbank an. Die Ausgabe des Befehls ist im folgenden Screenshot dargestellt.

Daten in MongoDB haben ein flexibles schema.documents in derselben Sammlung. Sie müssen nicht denselben Feldsatz oder dieselbe Struktur haben, und gemeinsame Felder in den Dokumenten einer Sammlung können unterschiedliche Datentypen enthalten.

Einige Überlegungen beim Entwerfen des Schemas in MongoDB

  • Entwerfen Sie Ihr Schema gemäß den Benutzeranforderungen.

  • Kombinieren Sie Objekte zu einem Dokument, wenn Sie sie zusammen verwenden möchten. Andernfalls trennen Sie sie (stellen Sie jedoch sicher, dass keine Verknüpfungen erforderlich sind).

  • Duplizieren Sie die Daten (aber begrenzt), da der Speicherplatz im Vergleich zur Rechenzeit günstig ist.

  • Joins beim Schreiben, nicht beim Lesen.

  • Optimieren Sie Ihr Schema für die häufigsten Anwendungsfälle.

  • Führen Sie eine komplexe Aggregation im Schema durch.

Beispiel

Angenommen, ein Client benötigt ein Datenbankdesign für sein Blog / seine Website und erkennt die Unterschiede zwischen dem RDBMS- und dem MongoDB-Schemadesign. Die Website hat die folgenden Anforderungen.

  • Jeder Beitrag hat den eindeutigen Titel, die Beschreibung und die URL.
  • Jeder Beitrag kann ein oder mehrere Tags haben.
  • Jeder Beitrag hat den Namen seines Herausgebers und die Gesamtzahl der Likes.
  • Jeder Beitrag enthält Kommentare von Benutzern mit Namen, Nachricht, Datenzeit und Likes.
  • Zu jedem Beitrag kann es null oder mehr Kommentare geben.

Im RDBMS-Schema enthält das Design für die oben genannten Anforderungen mindestens drei Tabellen.

Im MongoDB-Schema verfügt das Design über einen Sammlungsbeitrag und die folgende Struktur:

{
   _id: POST_ID
   title: TITLE_OF_POST, 
   description: POST_DESCRIPTION,
   by: POST_BY,
   url: URL_OF_POST,
   tags: [TAG1, TAG2, TAG3],
   likes: TOTAL_LIKES, 
   comments: [	
      {
         user:'COMMENT_BY',
         message: TEXT,
         dateCreated: DATE_TIME,
         like: LIKES 
      },
      {
         user:'COMMENT_BY',
         message: TEXT,
         dateCreated: DATE_TIME,
         like: LIKES
      }
   ]
}

Während Sie die Daten anzeigen, müssen Sie in RDBMS drei Tabellen verbinden, und in MongoDB werden Daten nur aus einer Sammlung angezeigt.

In diesem Kapitel erfahren Sie, wie Sie eine Datenbank in MongoDB erstellen.

Der Befehl use

MongoDB use DATABASE_NAMEwird zum Erstellen einer Datenbank verwendet. Der Befehl erstellt eine neue Datenbank, wenn diese nicht vorhanden ist. Andernfalls wird die vorhandene Datenbank zurückgegeben.

Syntax

Grundlegende Syntax von use DATABASE Aussage ist wie folgt -

use DATABASE_NAME

Beispiel

Wenn Sie eine Datenbank mit Namen verwenden möchten <mydb>, dann use DATABASE Aussage wäre wie folgt -

>use mydb
switched to db mydb

Verwenden Sie den Befehl, um Ihre aktuell ausgewählte Datenbank zu überprüfen db

>db
mydb

Wenn Sie Ihre Datenbankliste überprüfen möchten, verwenden Sie den Befehl show dbs.

>show dbs
local     0.78125GB
test      0.23012GB

Ihre erstellte Datenbank (mydb) ist in der Liste nicht vorhanden. Um die Datenbank anzuzeigen, müssen Sie mindestens ein Dokument einfügen.

>db.movie.insert({"name":"tutorials point"})
>show dbs
local      0.78125GB
mydb       0.23012GB
test       0.23012GB

In MongoDB ist die Standarddatenbank test. Wenn Sie keine Datenbank erstellt haben, werden die Sammlungen in der Testdatenbank gespeichert.

In diesem Kapitel erfahren Sie, wie Sie eine Datenbank mit dem Befehl MongoDB löschen.

Die dropDatabase () -Methode

MongoDB db.dropDatabase() Befehl wird verwendet, um eine vorhandene Datenbank zu löschen.

Syntax

Grundlegende Syntax von dropDatabase() Befehl ist wie folgt -

db.dropDatabase()

Dadurch wird die ausgewählte Datenbank gelöscht. Wenn Sie keine Datenbank ausgewählt haben, wird die Standard-Testdatenbank gelöscht.

Beispiel

Überprüfen Sie zunächst die Liste der verfügbaren Datenbanken mit dem Befehl: show dbs.

>show dbs
local      0.78125GB
mydb       0.23012GB
test       0.23012GB
>

Wenn Sie eine neue Datenbank löschen möchten <mydb>, dann dropDatabase() Befehl wäre wie folgt -

>use mydb
switched to db mydb
>db.dropDatabase()
>{ "dropped" : "mydb", "ok" : 1 }
>

Überprüfen Sie nun die Liste der Datenbanken.

>show dbs
local      0.78125GB
test       0.23012GB
>

In diesem Kapitel erfahren Sie, wie Sie mit MongoDB eine Sammlung erstellen.

Die Methode createCollection ()

MongoDB db.createCollection(name, options) wird verwendet, um eine Sammlung zu erstellen.

Syntax

Grundlegende Syntax von createCollection() Befehl ist wie folgt -

db.createCollection(name, options)

Im Befehl name ist der Name der zu erstellenden Sammlung. Options ist ein Dokument und wird verwendet, um die Konfiguration der Sammlung anzugeben.

Parameter Art Beschreibung
Name String Name der zu erstellenden Sammlung
Optionen Dokument (Optional) Geben Sie Optionen zur Speichergröße und Indizierung an

Der Parameter Options ist optional, daher müssen Sie nur den Namen der Sammlung angeben. Im Folgenden finden Sie eine Liste der Optionen, die Sie verwenden können:

Feld Art Beschreibung
gekappt Boolescher Wert (Optional) Wenn true, wird eine begrenzte Sammlung aktiviert. Capped Collection ist eine Sammlung mit fester Größe, die ihre ältesten Einträge automatisch überschreibt, wenn sie ihre maximale Größe erreicht.If you specify true, you need to specify size parameter also.
autoIndexId Boolescher Wert (Optional) Wenn true, wird automatisch ein Index für das Feld _id erstellt. Der Standardwert ist false.
Größe Nummer (Optional) Gibt eine maximale Größe in Byte für eine begrenzte Sammlung an. If capped is true, then you need to specify this field also.
max Nummer (Optional) Gibt die maximale Anzahl von Dokumenten an, die in der begrenzten Sammlung zulässig sind.

Während des Einfügens des Dokuments überprüft MongoDB zuerst das Größenfeld der begrenzten Sammlung und dann das Feld max.

Beispiele

Grundlegende Syntax von createCollection() Methode ohne Optionen ist wie folgt -

>use test
switched to db test
>db.createCollection("mycollection")
{ "ok" : 1 }
>

Sie können die erstellte Sammlung mit dem Befehl überprüfen show collections.

>show collections
mycollection
system.indexes

Das folgende Beispiel zeigt die Syntax von createCollection() Methode mit wenigen wichtigen Optionen -

>db.createCollection("mycol", { capped : true, autoIndexId : true, size : 
   6142800, max : 10000 } )
{ "ok" : 1 }
>

In MongoDB müssen Sie keine Sammlung erstellen. MongoDB erstellt automatisch eine Sammlung, wenn Sie ein Dokument einfügen.

>db.tutorialspoint.insert({"name" : "tutorialspoint"})
>show collections
mycol
mycollection
system.indexes
tutorialspoint
>

In diesem Kapitel erfahren Sie, wie Sie eine Sammlung mit MongoDB löschen.

Die drop () Methode

MongoDBs db.collection.drop() wird verwendet, um eine Sammlung aus der Datenbank zu löschen.

Syntax

Grundlegende Syntax von drop() Befehl ist wie folgt -

db.COLLECTION_NAME.drop()

Beispiel

Überprüfen Sie zunächst die verfügbaren Sammlungen in Ihrer Datenbank mydb.

>use mydb
switched to db mydb
>show collections
mycol
mycollection
system.indexes
tutorialspoint
>

Lassen Sie nun die Sammlung mit dem Namen fallen mycollection.

>db.mycollection.drop()
true
>

Überprüfen Sie erneut die Liste der Sammlungen in der Datenbank.

>show collections
mycol
system.indexes
tutorialspoint
>

Die Methode drop () gibt true zurück, wenn die ausgewählte Sammlung erfolgreich gelöscht wurde, andernfalls wird false zurückgegeben.

MongoDB unterstützt viele Datentypen. Einige von ihnen sind -

  • String- Dies ist der am häufigsten verwendete Datentyp zum Speichern der Daten. Die Zeichenfolge in MongoDB muss UTF-8-gültig sein.

  • Integer- In diesem Typ wird ein numerischer Wert gespeichert. Die Ganzzahl kann je nach Server 32 Bit oder 64 Bit betragen.

  • Boolean - Dieser Typ wird zum Speichern eines booleschen Werts (true / false) verwendet.

  • Double - Dieser Typ wird zum Speichern von Gleitkommawerten verwendet.

  • Min/ Max keys - Dieser Typ wird verwendet, um einen Wert mit den niedrigsten und höchsten BSON-Elementen zu vergleichen.

  • Arrays - Dieser Typ wird verwendet, um Arrays oder Listen- oder Mehrfachwerte in einem Schlüssel zu speichern.

  • Timestamp- Zeitstempel. Dies kann nützlich sein, um aufzuzeichnen, wenn ein Dokument geändert oder hinzugefügt wurde.

  • Object - Dieser Datentyp wird für eingebettete Dokumente verwendet.

  • Null - Dieser Typ wird zum Speichern eines Nullwerts verwendet.

  • Symbol- Dieser Datentyp wird identisch mit einer Zeichenfolge verwendet. Es ist jedoch im Allgemeinen für Sprachen reserviert, die einen bestimmten Symboltyp verwenden.

  • Date - Dieser Datentyp wird verwendet, um das aktuelle Datum oder die aktuelle Uhrzeit im UNIX-Zeitformat zu speichern. Sie können Ihre eigene Datums- und Uhrzeitangabe angeben, indem Sie ein Objekt mit Datum erstellen und Tag, Monat und Jahr übergeben.

  • Object ID - In diesem Datentyp wird die ID des Dokuments gespeichert.

  • Binary data - Dieser Datentyp wird zum Speichern von Binärdaten verwendet.

  • Code - Dieser Datentyp wird zum Speichern von JavaScript-Code im Dokument verwendet.

  • Regular expression - Dieser Datentyp wird zum Speichern von regulären Ausdrücken verwendet.

In diesem Kapitel erfahren Sie, wie Sie ein Dokument in die MongoDB-Sammlung einfügen.

Die insert () -Methode

Um Daten in die MongoDB-Sammlung einzufügen, müssen Sie MongoDBs verwenden insert() oder save() Methode.

Syntax

Die grundlegende Syntax von insert() Befehl ist wie folgt -

>db.COLLECTION_NAME.insert(document)

Beispiel

>db.mycol.insert({
   _id: ObjectId(7df78ad8902c),
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
})

Hier mycolist unser Sammlungsname, wie er im vorherigen Kapitel erstellt wurde. Wenn die Sammlung nicht in der Datenbank vorhanden ist, erstellt MongoDB diese Sammlung und fügt ein Dokument ein.

Wenn wir im eingefügten Dokument den Parameter _id nicht angeben, weist MongoDB diesem Dokument eine eindeutige ObjectId zu.

_id ist eine 12-Byte-Hexadezimalzahl, die für jedes Dokument in einer Sammlung eindeutig ist. 12 Bytes werden wie folgt aufgeteilt:

_id: ObjectId(4 bytes timestamp, 3 bytes machine id, 2 bytes process id, 
   3 bytes incrementer)

Um mehrere Dokumente in eine einzelne Abfrage einzufügen, können Sie im Befehl insert () ein Array von Dokumenten übergeben.

Beispiel

>db.post.insert([
   {
      title: 'MongoDB Overview', 
      description: 'MongoDB is no sql database',
      by: 'tutorials point',
      url: 'http://www.tutorialspoint.com',
      tags: ['mongodb', 'database', 'NoSQL'],
      likes: 100
   },
	
   {
      title: 'NoSQL Database', 
      description: "NoSQL database doesn't have tables",
      by: 'tutorials point',
      url: 'http://www.tutorialspoint.com',
      tags: ['mongodb', 'database', 'NoSQL'],
      likes: 20, 
      comments: [	
         {
            user:'user1',
            message: 'My first comment',
            dateCreated: new Date(2013,11,10,2,35),
            like: 0 
         }
      ]
   }
])

Zum Einfügen des Dokuments können Sie verwenden db.post.save(document)ebenfalls. Wenn Sie nicht angeben_id im Dokument dann save() Methode funktioniert genauso wie insert()Methode. Wenn Sie _id angeben, werden die gesamten Daten des Dokuments ersetzt, das _id enthält, wie in der Methode save () angegeben.

In diesem Kapitel erfahren Sie, wie Sie Dokumente aus der MongoDB-Sammlung abfragen.

Die find () -Methode

Um Daten aus der MongoDB-Sammlung abzufragen, müssen Sie MongoDBs verwenden find() Methode.

Syntax

Die grundlegende Syntax von find() Methode ist wie folgt -

>db.COLLECTION_NAME.find()

find() Die Methode zeigt alle Dokumente nicht strukturiert an.

Die hübsche () Methode

Sie können verwenden, um die Ergebnisse formatiert anzuzeigen pretty() Methode.

Syntax

>db.mycol.find().pretty()

Beispiel

>db.mycol.find().pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

Abgesehen von der find () -Methode gibt es findOne() Methode, die nur ein Dokument zurückgibt.

RDBMS Where-Klauseläquivalente in MongoDB

Um das Dokument unter bestimmten Bedingungen abzufragen, können Sie die folgenden Vorgänge verwenden.

Betrieb Syntax Beispiel RDBMS-Äquivalent
Gleichberechtigung {<Schlüssel>: <Wert>} db.mycol.find ({"by": "tutorials point"}). pretty () where by = 'Tutorials zeigen'
Weniger als {<Schlüssel>: {$ lt: <Wert>}} db.mycol.find ({"liken": {$ lt: 50}}). hübsch () wo mag <50
Weniger als gleich {<key>: {$ lte: <value>}} db.mycol.find ({"liken": {$ lte: 50}}). hübsch () wo mag <= 50
Größer als {<key>: {$ gt: <value>}} db.mycol.find ({"liken": {$ gt: 50}}). hübsch () wo mag> 50
Größer als gleich {<key>: {$ gte: <value>}} db.mycol.find ({"liken": {$ gte: 50}}). hübsch () wo mag> = 50
Nicht gleich {<key>: {$ ne: <value>}} db.mycol.find ({"liken": {$ ne: 50}}). hübsch () wo mag! = 50

UND in MongoDB

Syntax

In dem find() Wenn Sie mehrere Schlüssel übergeben, indem Sie sie durch '' trennen, behandelt MongoDB dies als ANDBedingung. Es folgt die grundlegende Syntax vonAND - -

>db.mycol.find(
   {
      $and: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

Beispiel

Das folgende Beispiel zeigt alle Tutorials, die von 'tutorials point' geschrieben wurden und deren Titel 'MongoDB Overview' lautet.

>db.mycol.find({$and:[{"by":"tutorials point"},{"title": "MongoDB Overview"}]}).pretty() {
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}

Für das oben angegebene Beispiel entspricht die where-Klausel ' where by = 'tutorials point' AND title = 'MongoDB Overview' '. Sie können in der find-Klausel eine beliebige Anzahl von Schlüssel-Wert-Paaren übergeben.

ODER in MongoDB

Syntax

Um Dokumente basierend auf der ODER-Bedingung abzufragen, müssen Sie verwenden $orStichwort. Es folgt die grundlegende Syntax vonOR - -

>db.mycol.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

Beispiel

Das folgende Beispiel zeigt alle Tutorials, die von 'tutorials point' geschrieben wurden oder deren Titel 'MongoDB Overview' lautet.

>db.mycol.find({$or:[{"by":"tutorials point"},{"title": "MongoDB Overview"}]}).pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

UND und ODER zusammen verwenden

Beispiel

Das folgende Beispiel zeigt die Dokumente, deren Likes größer als 10 sind und deren Titel entweder "MongoDB Overview" oder "tutorials point" lautet. Äquivalente SQL where-Klausel'where likes>10 AND (by = 'tutorials point' OR title = 'MongoDB Overview')'

>db.mycol.find({"likes": {$gt:10}, $or: [{"by": "tutorials point"},
   {"title": "MongoDB Overview"}]}).pretty()
{
   "_id": ObjectId(7df78ad8902c),
   "title": "MongoDB Overview", 
   "description": "MongoDB is no sql database",
   "by": "tutorials point",
   "url": "http://www.tutorialspoint.com",
   "tags": ["mongodb", "database", "NoSQL"],
   "likes": "100"
}
>

MongoDBs update() und save()Methoden werden verwendet, um Dokumente in eine Sammlung zu aktualisieren. Die update () -Methode aktualisiert die Werte im vorhandenen Dokument, während die save () -Methode das vorhandene Dokument durch das in der save () -Methode übergebene Dokument ersetzt.

MongoDB Update () -Methode

Die update () -Methode aktualisiert die Werte im vorhandenen Dokument.

Syntax

Die grundlegende Syntax von update() Methode ist wie folgt -

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)

Beispiel

Beachten Sie, dass die mycol-Sammlung die folgenden Daten enthält.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

Im folgenden Beispiel wird der neue Titel "New MongoDB Tutorial" der Dokumente festgelegt, deren Titel "MongoDB Overview" lautet.

>db.mycol.update({'title':'MongoDB Overview'},{$set:{'title':'New MongoDB Tutorial'}})
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec5), "title":"New MongoDB Tutorial"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

Standardmäßig aktualisiert MongoDB nur ein einziges Dokument. Um mehrere Dokumente zu aktualisieren, müssen Sie den Parameter 'multi' auf true setzen.

>db.mycol.update({'title':'MongoDB Overview'},
   {$set:{'title':'New MongoDB Tutorial'}},{multi:true})

MongoDB Save () -Methode

Das save() Die Methode ersetzt das vorhandene Dokument durch das neue Dokument, das in der save () -Methode übergeben wurde.

Syntax

Die grundlegende Syntax von MongoDB save() Methode ist unten gezeigt -

>db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

Beispiel

Das folgende Beispiel ersetzt das Dokument durch die _id '5983548781331adf45ec5'.

>db.mycol.save(
   {
      "_id" : ObjectId(5983548781331adf45ec5), "title":"Tutorials Point New Topic",
      "by":"Tutorials Point"
   }
)
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec5), "title":"Tutorials Point New Topic",
   "by":"Tutorials Point"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

In diesem Kapitel erfahren Sie, wie Sie ein Dokument mit MongoDB löschen.

Die Methode remove ()

MongoDBs remove()Methode wird verwendet, um ein Dokument aus der Sammlung zu entfernen. Die Methode remove () akzeptiert zwei Parameter. Eines ist das Löschkriterium und das zweite ist das Flag justOne.

  • deletion criteria - (Optionale) Löschkriterien gemäß Dokumenten werden entfernt.

  • justOne - (Optional) Wenn auf true oder 1 gesetzt, entfernen Sie nur ein Dokument.

Syntax

Grundlegende Syntax von remove() Methode ist wie folgt -

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

Beispiel

Beachten Sie, dass die mycol-Sammlung die folgenden Daten enthält.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

Im folgenden Beispiel werden alle Dokumente entfernt, deren Titel "MongoDB-Übersicht" lautet.

>db.mycol.remove({'title':'MongoDB Overview'})
>db.mycol.find()
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}
>

Entfernen Sie nur einen

Wenn mehrere Datensätze vorhanden sind und Sie nur den ersten Datensatz löschen möchten, legen Sie fest justOne Parameter in remove() Methode.

>db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)

Alle Dokumente entfernen

Wenn Sie keine Löschkriterien angeben, löscht MongoDB ganze Dokumente aus der Sammlung. This is equivalent of SQL's truncate command.

>db.mycol.remove({})
>db.mycol.find()
>

In MongoDB bedeutet Projektion, dass nur die erforderlichen Daten ausgewählt werden, anstatt alle Daten eines Dokuments auszuwählen. Wenn ein Dokument 5 Felder enthält und Sie nur 3 anzeigen müssen, wählen Sie nur 3 Felder aus.

Die find () -Methode

MongoDBs find()Die in MongoDB Query Document erläuterte Methode akzeptiert den zweiten optionalen Parameter, nämlich die Liste der Felder, die Sie abrufen möchten. In MongoDB, wenn Sie ausführenfind()Methode, dann zeigt es alle Felder eines Dokuments. Um dies einzuschränken, müssen Sie eine Liste von Feldern mit dem Wert 1 oder 0 festlegen. Mit 1 wird das Feld angezeigt, während mit 0 die Felder ausgeblendet werden.

Syntax

Die grundlegende Syntax von find() Methode mit Projektion ist wie folgt -

>db.COLLECTION_NAME.find({},{KEY:1})

Beispiel

Betrachten Sie die Sammlung mycol hat die folgenden Daten -

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

Das folgende Beispiel zeigt den Titel des Dokuments an, während das Dokument abgefragt wird.

>db.mycol.find({},{"title":1,_id:0})
{"title":"MongoDB Overview"}
{"title":"NoSQL Overview"}
{"title":"Tutorials Point Overview"}
>

bitte beachten Sie _id Feld wird während der Ausführung immer angezeigt find() Methode, wenn Sie dieses Feld nicht möchten, müssen Sie es auf 0 setzen.

In diesem Kapitel erfahren Sie, wie Sie Datensätze mit MongoDB einschränken.

Die Limit () -Methode

Um die Datensätze in MongoDB einzuschränken, müssen Sie verwenden limit()Methode. Die Methode akzeptiert ein Argument vom Typ Nummer, dh die Anzahl der Dokumente, die angezeigt werden sollen.

Syntax

Die grundlegende Syntax von limit() Methode ist wie folgt -

>db.COLLECTION_NAME.find().limit(NUMBER)

Beispiel

Betrachten Sie die Sammlung Myycol hat die folgenden Daten.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

Das folgende Beispiel zeigt nur zwei Dokumente an, während das Dokument abgefragt wird.

>db.mycol.find({},{"title":1,_id:0}).limit(2)
{"title":"MongoDB Overview"}
{"title":"NoSQL Overview"}
>

Wenn Sie das Zahlenargument nicht in angeben limit() Methode dann zeigt es alle Dokumente aus der Sammlung.

MongoDB Skip () -Methode

Neben der Methode limit () gibt es noch eine weitere Methode skip() Dies akzeptiert auch ein Argument vom Typ Nummer und wird verwendet, um die Anzahl der Dokumente zu überspringen.

Syntax

Die grundlegende Syntax von skip() Methode ist wie folgt -

>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

Beispiel

Das folgende Beispiel zeigt nur das zweite Dokument an.

>db.mycol.find({},{"title":1,_id:0}).limit(1).skip(1)
{"title":"NoSQL Overview"}
>

Bitte beachten Sie den Standardwert in skip() Methode ist 0.

In diesem Kapitel erfahren Sie, wie Sie Datensätze in MongoDB sortieren.

Die sort () -Methode

Um Dokumente in MongoDB zu sortieren, müssen Sie verwenden sort()Methode. Die Methode akzeptiert ein Dokument, das eine Liste von Feldern zusammen mit ihrer Sortierreihenfolge enthält. Zur Angabe der Sortierreihenfolge werden 1 und -1 verwendet. 1 wird für aufsteigende Reihenfolge verwendet, während -1 für absteigende Reihenfolge verwendet wird.

Syntax

Die grundlegende Syntax von sort() Methode ist wie folgt -

>db.COLLECTION_NAME.find().sort({KEY:1})

Beispiel

Betrachten Sie die Sammlung Myycol hat die folgenden Daten.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"}

Im folgenden Beispiel werden die nach Titel sortierten Dokumente in absteigender Reihenfolge angezeigt.

>db.mycol.find({},{"title":1,_id:0}).sort({"title":-1})
{"title":"Tutorials Point Overview"}
{"title":"NoSQL Overview"}
{"title":"MongoDB Overview"}
>

Bitte beachten Sie, wenn Sie die Sortiereinstellung nicht angeben, dann sort() Methode zeigt die Dokumente in aufsteigender Reihenfolge an.

Indizes unterstützen die effiziente Lösung von Abfragen. Ohne Indizes muss MongoDB jedes Dokument einer Sammlung scannen, um die Dokumente auszuwählen, die der Abfrageanweisung entsprechen. Dieser Scan ist äußerst ineffizient und erfordert, dass MongoDB ein großes Datenvolumen verarbeitet.

Indizes sind spezielle Datenstrukturen, die einen kleinen Teil des Datensatzes in leicht zu durchlaufender Form speichern. Der Index speichert den Wert eines bestimmten Felds oder einer Reihe von Feldern, geordnet nach dem Wert des Feldes, wie im Index angegeben.

Die Methode sureIndex ()

Um einen Index zu erstellen, müssen Sie die Methode verifyIndex () von MongoDB verwenden.

Syntax

Die grundlegende Syntax von ensureIndex() Methode ist wie folgt ().

>db.COLLECTION_NAME.ensureIndex({KEY:1})

Hier ist der Schlüssel der Name des Feldes, für das Sie einen Index erstellen möchten, und 1 steht für aufsteigende Reihenfolge. Um einen Index in absteigender Reihenfolge zu erstellen, müssen Sie -1 verwenden.

Beispiel

>db.mycol.ensureIndex({"title":1})
>

Im ensureIndex() Methode können Sie mehrere Felder übergeben, um einen Index für mehrere Felder zu erstellen.

>db.mycol.ensureIndex({"title":1,"description":-1})
>

ensureIndex()Die Methode akzeptiert auch eine Liste von Optionen (die optional sind). Es folgt die Liste -

Parameter Art Beschreibung
Hintergrund Boolescher Wert Erstellt den Index im Hintergrund, sodass beim Erstellen eines Index andere Datenbankaktivitäten nicht blockiert werden. Geben Sie true an, um im Hintergrund zu erstellen. Der Standardwert istfalse.
einzigartig Boolescher Wert Erstellt einen eindeutigen Index, sodass die Sammlung das Einfügen von Dokumenten nicht akzeptiert, bei denen der Indexschlüssel oder die Indexschlüssel mit einem vorhandenen Wert im Index übereinstimmen. Geben Sie true an, um einen eindeutigen Index zu erstellen. Der Standardwert istfalse.
Name string The name of the index. If unspecified, MongoDB generates an index name by concatenating the names of the indexed fields and the sort order.
dropDups Boolean Creates a unique index on a field that may have duplicates. MongoDB indexes only the first occurrence of a key and removes all documents from the collection that contain subsequent occurrences of that key. Specify true to create unique index. The default value is false.
sparse Boolean If true, the index only references documents with the specified field. These indexes use less space but behave differently in some situations (particularly sorts). The default value is false.
expireAfterSeconds integer Specifies a value, in seconds, as a TTL to control how long MongoDB retains documents in this collection.
v index version The index version number. The default index version depends on the version of MongoDB running when creating the index.
weights document The weight is a number ranging from 1 to 99,999 and denotes the significance of the field relative to the other indexed fields in terms of the score.
default_language string For a text index, the language that determines the list of stop words and the rules for the stemmer and tokenizer. The default value is english.
language_override string For a text index, specify the name of the field in the document that contains, the language to override the default language. The default value is language.

Aggregations operations process data records and return computed results. Aggregation operations group values from multiple documents together, and can perform a variety of operations on the grouped data to return a single result. In SQL count(*) and with group by is an equivalent of mongodb aggregation.

The aggregate() Method

For the aggregation in MongoDB, you should use aggregate() method.

Syntax

Basic syntax of aggregate() method is as follows −

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

Example

In the collection you have the following data −

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
},
{
   _id: ObjectId(7df78ad8902d)
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'tutorials point',
   url: 'http://www.tutorialspoint.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
},
{
   _id: ObjectId(7df78ad8902e)
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
},

Now from the above collection, if you want to display a list stating how many tutorials are written by each user, then you will use the following aggregate() method −

> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
{
   "result" : [
      {
         "_id" : "tutorials point",
         "num_tutorial" : 2
      },
      {
         "_id" : "Neo4j",
         "num_tutorial" : 1
      }
   ],
   "ok" : 1
}
>

Sql equivalent query for the above use case will be select by_user, count(*) from mycol group by by_user.

In the above example, we have grouped documents by field by_user and on each occurrence of by_user previous value of sum is incremented. Following is a list of available aggregation expressions.

Expression Description Example
$sum Sums up the defined value from all documents in the collection. db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : "$likes"}}}])
$avg Calculates the average of all given values from all documents in the collection. db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$avg : "$likes"}}}])
$min Gets the minimum of the corresponding values from all documents in the collection. db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$min : "$likes"}}}])
$max Gets the maximum of the corresponding values from all documents in the collection. db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$max : "$likes"}}}])
$push Inserts the value to an array in the resulting document. db.mycol.aggregate([{$group : {_id : "$by_user", url : {$push: "$url"}}}])
$addToSet Inserts the value to an array in the resulting document but does not create duplicates. db.mycol.aggregate([{$group : {_id : "$by_user", url : {$addToSet : "$url"}}}])
$first Gets the first document from the source documents according to the grouping. Typically this makes only sense together with some previously applied “$sort”-stage. db.mycol.aggregate([{$group : {_id : "$by_user", first_url : {$first : "$url"}}}])
$last Gets the last document from the source documents according to the grouping. Typically this makes only sense together with some previously applied “$sort”-stage. db.mycol.aggregate([{$group : {_id : "$by_user", last_url : {$last : "$url"}}}])

Pipeline Concept

In UNIX command, shell pipeline means the possibility to execute an operation on some input and use the output as the input for the next command and so on. MongoDB also supports same concept in aggregation framework. There is a set of possible stages and each of those is taken as a set of documents as an input and produces a resulting set of documents (or the final resulting JSON document at the end of the pipeline). This can then in turn be used for the next stage and so on.

Following are the possible stages in aggregation framework −

  • $project − Used to select some specific fields from a collection.

  • $match − This is a filtering operation and thus this can reduce the amount of documents that are given as input to the next stage.

  • $group − This does the actual aggregation as discussed above.

  • $sort − Sorts the documents.

  • $skip − With this, it is possible to skip forward in the list of documents for a given amount of documents.

  • $limit − This limits the amount of documents to look at, by the given number starting from the current positions.

  • $unwind − This is used to unwind document that are using arrays. When using an array, the data is kind of pre-joined and this operation will be undone with this to have individual documents again. Thus with this stage we will increase the amount of documents for the next stage.

Replication is the process of synchronizing data across multiple servers. Replication provides redundancy and increases data availability with multiple copies of data on different database servers. Replication protects a database from the loss of a single server. Replication also allows you to recover from hardware failure and service interruptions. With additional copies of the data, you can dedicate one to disaster recovery, reporting, or backup.

Why Replication?

  • To keep your data safe
  • High (24*7) availability of data
  • Disaster recovery
  • No downtime for maintenance (like backups, index rebuilds, compaction)
  • Read scaling (extra copies to read from)
  • Replica set is transparent to the application

How Replication Works in MongoDB

MongoDB achieves replication by the use of replica set. A replica set is a group of mongod instances that host the same data set. In a replica, one node is primary node that receives all write operations. All other instances, such as secondaries, apply operations from the primary so that they have the same data set. Replica set can have only one primary node.

  • Replica set is a group of two or more nodes (generally minimum 3 nodes are required).

  • In a replica set, one node is primary node and remaining nodes are secondary.

  • All data replicates from primary to secondary node.

  • At the time of automatic failover or maintenance, election establishes for primary and a new primary node is elected.

  • After the recovery of failed node, it again join the replica set and works as a secondary node.

A typical diagram of MongoDB replication is shown in which client application always interact with the primary node and the primary node then replicates the data to the secondary nodes.

Replica Set Features

  • A cluster of N nodes
  • Any one node can be primary
  • All write operations go to primary
  • Automatic failover
  • Automatic recovery
  • Consensus election of primary

Set Up a Replica Set

In this tutorial, we will convert standalone MongoDB instance to a replica set. To convert to replica set, following are the steps −

  • Shutdown already running MongoDB server.

  • Start the MongoDB server by specifying -- replSet option. Following is the basic syntax of --replSet −

mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"

Example

mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0
  • It will start a mongod instance with the name rs0, on port 27017.

  • Now start the command prompt and connect to this mongod instance.

  • In Mongo client, issue the command rs.initiate() to initiate a new replica set.

  • To check the replica set configuration, issue the command rs.conf(). To check the status of replica set issue the command rs.status().

Mitglieder zum Replikatsatz hinzufügen

Starten Sie Mongod-Instanzen auf mehreren Computern, um Mitglieder zum Replikatsatz hinzuzufügen. Starten Sie nun einen Mongo-Client und geben Sie einen Befehl ausrs.add().

Syntax

Die grundlegende Syntax von rs.add() Befehl ist wie folgt -

>rs.add(HOST_NAME:PORT)

Beispiel

Angenommen, Ihr mongod-Instanzname lautet mongod1.net und es läuft auf Port 27017. Geben Sie den Befehl aus, um diese Instanz zum Replikatsatz hinzuzufügenrs.add() im Mongo Client.

>rs.add("mongod1.net:27017")
>

Sie können dem Replikatsatz nur dann eine Mongod-Instanz hinzufügen, wenn Sie mit dem Primärknoten verbunden sind. Geben Sie den Befehl aus, um zu überprüfen, ob Sie mit der primären Verbindung verbunden sind oder nichtdb.isMaster() im Mongo Client.

Beim Sharding werden Datensätze auf mehreren Computern gespeichert, und es ist der Ansatz von MongoDB, die Anforderungen des Datenwachstums zu erfüllen. Mit zunehmender Datengröße reicht eine einzelne Maschine möglicherweise nicht aus, um die Daten zu speichern oder einen akzeptablen Lese- und Schreibdurchsatz bereitzustellen. Sharding löst das Problem mit der horizontalen Skalierung. Mit Sharding fügen Sie weitere Maschinen hinzu, um das Datenwachstum und die Anforderungen von Lese- und Schreibvorgängen zu unterstützen.

Warum Scherben?

  • Bei der Replikation werden alle Schreibvorgänge an den Masterknoten gesendet
  • Latenzempfindliche Abfragen werden weiterhin an den Master gesendet
  • Einzelne Replikatsätze sind auf 12 Knoten begrenzt
  • Der Speicher kann nicht groß genug sein, wenn der aktive Datensatz groß ist
  • Die lokale Festplatte ist nicht groß genug
  • Vertikale Skalierung ist zu teuer

Sharding in MongoDB

Das folgende Diagramm zeigt das Sharding in MongoDB mithilfe eines Sharded-Clusters.

In der folgenden Abbildung gibt es drei Hauptkomponenten:

  • Shards- Shards werden zum Speichern von Daten verwendet. Sie bieten hohe Verfügbarkeit und Datenkonsistenz. In der Produktionsumgebung ist jeder Shard ein separater Replikatsatz.

  • Config Servers- Konfigurationsserver speichern die Metadaten des Clusters. Diese Daten enthalten eine Zuordnung des Cluster-Datensatzes zu den Shards. Der Abfragerouter verwendet diese Metadaten, um Operationen auf bestimmte Shards auszurichten. In der Produktionsumgebung haben Sharded-Cluster genau 3 Konfigurationsserver.

  • Query Routers- Abfragerouter sind im Grunde genommen Mongo-Instanzen, Schnittstellen zu Clientanwendungen und direkte Operationen zum entsprechenden Shard. Der Abfrage-Router verarbeitet und zielt die Vorgänge auf Shards ab und gibt dann Ergebnisse an die Clients zurück. Ein Sharded-Cluster kann mehr als einen Abfragerouter enthalten, um die Clientanforderungslast aufzuteilen. Ein Client sendet Anforderungen an einen Abfragerouter. Im Allgemeinen verfügt ein Sharded-Cluster über viele Abfragerouter.

In diesem Kapitel erfahren Sie, wie Sie ein Backup in MongoDB erstellen.

MongoDB-Daten sichern

Um eine Sicherung der Datenbank in MongoDB zu erstellen, sollten Sie verwenden mongodumpBefehl. Dieser Befehl speichert die gesamten Daten Ihres Servers im Dump-Verzeichnis. Es stehen viele Optionen zur Verfügung, mit denen Sie die Datenmenge begrenzen oder eine Sicherung Ihres Remote-Servers erstellen können.

Syntax

Die grundlegende Syntax von mongodump Befehl ist wie folgt -

>mongodump

Beispiel

Starten Sie Ihren Mongod-Server. Angenommen, Ihr Mongod-Server wird auf dem Localhost und Port 27017 ausgeführt, öffnen Sie eine Eingabeaufforderung, wechseln Sie in das bin-Verzeichnis Ihrer Mongodb-Instanz und geben Sie den Befehl einmongodump

Beachten Sie, dass die mycol-Sammlung die folgenden Daten enthält.

>mongodump

Der Befehl stellt eine Verbindung zu dem Server her, auf dem ausgeführt wird 127.0.0.1 und Hafen 27017 und alle Daten des Servers in das Verzeichnis zurücksetzen /bin/dump/. Es folgt die Ausgabe des Befehls -

Im Folgenden finden Sie eine Liste der verfügbaren Optionen, die mit dem verwendet werden können mongodump Befehl.

Syntax Beschreibung Beispiel
mongodump --host HOST_NAME --port PORT_NUMBER Dieser Befehl sichert alle Datenbanken der angegebenen Mongod-Instanz. mongodump --host tutorialspoint.com --port 27017
mongodump --dbpath DB_PATH --out BACKUP_DIRECTORY Dieser Befehl sichert nur die angegebene Datenbank unter dem angegebenen Pfad. mongodump --dbpath / data / db / --out / data / backup /
mongodump --collection COLLECTION --db DB_NAME Dieser Befehl sichert nur die angegebene Sammlung der angegebenen Datenbank. mongodump --collection mycol --db test

Daten wiederherstellen

So stellen Sie Sicherungsdaten wieder her MongoDBs mongorestoreBefehl wird verwendet. Dieser Befehl stellt alle Daten aus dem Sicherungsverzeichnis wieder her.

Syntax

Die grundlegende Syntax von mongorestore Befehl ist -

>mongorestore

Es folgt die Ausgabe des Befehls -

Wenn Sie eine MongoDB-Bereitstellung vorbereiten, sollten Sie versuchen zu verstehen, wie sich Ihre Anwendung in der Produktion behaupten wird. Es ist eine gute Idee, einen konsistenten, wiederholbaren Ansatz für die Verwaltung Ihrer Bereitstellungsumgebung zu entwickeln, damit Sie Überraschungen minimieren können, sobald Sie in der Produktion sind.

Der beste Ansatz besteht darin, Prototypen für Ihre Einrichtung zu erstellen, Lasttests durchzuführen, wichtige Metriken zu überwachen und diese Informationen zur Skalierung Ihrer Einrichtung zu verwenden. Der wichtigste Teil des Ansatzes besteht darin, Ihr gesamtes System proaktiv zu überwachen. Auf diese Weise können Sie nachvollziehen, wie sich Ihr Produktionssystem vor der Bereitstellung verhält, und bestimmen, wo Sie Kapazitäten hinzufügen müssen. Ein Einblick in mögliche Spitzen in Ihrer Speichernutzung kann beispielsweise dazu beitragen, ein Schreibsperrfeuer zu löschen, bevor es beginnt.

Um Ihre Bereitstellung zu überwachen, bietet MongoDB einige der folgenden Befehle:

Mongostat

Dieser Befehl überprüft den Status aller laufenden Mongod-Instanzen und gibt Zähler für Datenbankoperationen zurück. Diese Zähler umfassen Einfügungen, Abfragen, Aktualisierungen, Löschungen und Cursor. Der Befehl zeigt auch an, wenn Sie auf Seitenfehler stoßen, und zeigt Ihren Sperrprozentsatz an. Dies bedeutet, dass Ihnen der Arbeitsspeicher ausgeht, die Schreibkapazität beeinträchtigt wird oder Leistungsprobleme auftreten.

Starten Sie Ihre Mongod-Instanz, um den Befehl auszuführen. Gehen Sie in einer anderen Eingabeaufforderung zubin Verzeichnis Ihrer Mongodb-Installation und Typ mongostat.

D:\set up\mongodb\bin>mongostat

Es folgt die Ausgabe des Befehls -

Mongotop

Dieser Befehl verfolgt und meldet die Lese- und Schreibaktivität der MongoDB-Instanz auf Sammlungsbasis. Standardmäßig,mongotopGibt in jeder Sekunde Informationen zurück, die Sie entsprechend ändern können. Sie sollten überprüfen, ob diese Lese- und Schreibaktivität Ihrer Anwendungsabsicht entspricht und Sie nicht zu viele Schreibvorgänge gleichzeitig in die Datenbank auslösen, zu häufig von einer Festplatte lesen oder die Größe Ihres Arbeitssatzes überschreiten.

Starten Sie Ihre Mongod-Instanz, um den Befehl auszuführen. Gehen Sie in einer anderen Eingabeaufforderung zubin Verzeichnis Ihrer Mongodb-Installation und Typ mongotop.

D:\set up\mongodb\bin>mongotop

Es folgt die Ausgabe des Befehls -

Wechseln mongotop Befehl, um Informationen weniger häufig zurückzugeben, geben Sie nach dem Befehl mongotop eine bestimmte Nummer an.

D:\set up\mongodb\bin>mongotop 30

Das obige Beispiel gibt alle 30 Sekunden Werte zurück.

Neben den MongoDB-Tools bietet 10gen einen kostenlosen, gehosteten Überwachungsdienst, den MongoDB Management Service (MMS), der ein Dashboard bietet und Ihnen einen Überblick über die Metriken Ihres gesamten Clusters gibt.

In diesem Kapitel erfahren Sie, wie Sie den MongoDB JDBC-Treiber einrichten.

Installation

Bevor Sie MongoDB in Ihren Java-Programmen verwenden, müssen Sie sicherstellen, dass auf dem Computer der MongoDB-JDBC-Treiber und Java eingerichtet sind. Sie können das Java-Tutorial für die Java-Installation auf Ihrem Computer überprüfen. Lassen Sie uns nun überprüfen, wie der MongoDB JDBC-Treiber eingerichtet wird.

  • Sie müssen das Glas vom Pfad Download mongo.jar herunterladen . Stellen Sie sicher, dass Sie die neueste Version herunterladen.

  • Sie müssen die Datei mongo.jar in Ihren Klassenpfad aufnehmen.

Verbindung zur Datenbank herstellen

Um eine Datenbank zu verbinden, müssen Sie den Datenbanknamen angeben. Wenn die Datenbank nicht vorhanden ist, erstellt MongoDB sie automatisch.

Im Folgenden finden Sie das Code-Snippet, mit dem Sie eine Verbindung zur Datenbank herstellen können.

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class ConnectToDB { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
   
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 
      System.out.println("Credentials ::"+ credential);     
   } 
}

Lassen Sie uns nun das obige Programm kompilieren und ausführen, um unsere Datenbank myDb wie unten gezeigt zu erstellen.

$javac ConnectToDB.java 
$java ConnectToDB

Beim Ausführen des obigen Programms erhalten Sie die folgende Ausgabe.

Connected to the database successfully 
Credentials ::MongoCredential{
   mechanism = null, 
   userName = 'sampleUser', 
   source = 'myDb', 
   password = <hidden>, 
   mechanismProperties = {}
}

Erstellen Sie eine Sammlung

Um eine Sammlung zu erstellen, createCollection() Methode von com.mongodb.client.MongoDatabase Klasse wird verwendet.

Im Folgenden finden Sie das Code-Snippet zum Erstellen einer Sammlung:

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class CreatingCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      //Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      //Creating a collection 
      database.createCollection("sampleCollection"); 
      System.out.println("Collection created successfully"); 
   } 
}

Beim Kompilieren erhalten Sie mit dem obigen Programm das folgende Ergebnis:

Connected to the database successfully 
Collection created successfully

Sammlung abrufen / auswählen

Um eine Sammlung aus der Datenbank abzurufen / auszuwählen, getCollection() Methode von com.mongodb.client.MongoDatabase Klasse wird verwendet.

Es folgt das Programm zum Abrufen / Auswählen einer Sammlung -

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 

import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class selectingCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Creating a collection 
      System.out.println("Collection created successfully"); 

      // Retieving a collection
      MongoCollection<Document> collection = database.getCollection("myCollection"); 
      System.out.println("Collection myCollection selected successfully"); 
   }
}

Beim Kompilieren erhalten Sie mit dem obigen Programm das folgende Ergebnis:

Connected to the database successfully 
Collection created successfully 
Collection myCollection selected successfully

Dokument einfügen

Um ein Dokument in MongoDB einzufügen, insert() Methode von com.mongodb.client.MongoCollection Klasse wird verwendet.

Es folgt das Code-Snippet zum Einfügen eines Dokuments:

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 

import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class InsertingDocument { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection"); 
      System.out.println("Collection sampleCollection selected successfully");

      Document document = new Document("title", "MongoDB") 
      .append("id", 1)
      .append("description", "database") 
      .append("likes", 100) 
      .append("url", "http://www.tutorialspoint.com/mongodb/") 
      .append("by", "tutorials point");  
      collection.insertOne(document); 
      System.out.println("Document inserted successfully");     
   } 
}

Beim Kompilieren erhalten Sie mit dem obigen Programm das folgende Ergebnis:

Connected to the database successfully 
Collection sampleCollection selected successfully 
Document inserted successfully

Alle Dokumente abrufen

Um alle Dokumente aus der Sammlung auszuwählen, find() Methode von com.mongodb.client.MongoCollectionKlasse wird verwendet. Diese Methode gibt einen Cursor zurück, daher müssen Sie diesen Cursor iterieren.

Es folgt das Programm zur Auswahl aller Dokumente -

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase;  

import java.util.Iterator; 
import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class RetrievingAllDocuments { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential;
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Retrieving a collection 
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection sampleCollection selected successfully"); 

      // Getting the iterable object 
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 
    
      while (it.hasNext()) {  
         System.out.println(it.next());  
      i++; 
      }
   } 
}

Beim Kompilieren erhalten Sie mit dem obigen Programm das folgende Ergebnis:

Document{{
   _id = 5967745223993a32646baab8, 
   title = MongoDB, 
   id = 1, 
   description = database, 
   likes = 100, 
   url = http://www.tutorialspoint.com/mongodb/, by = tutorials point
}}  
Document{{
   _id = 7452239959673a32646baab8, 
   title = RethinkDB, 
   id = 2, 
   description = database, 
   likes = 200, 
   url = http://www.tutorialspoint.com/rethinkdb/, by = tutorials point
}}

Dokument aktualisieren

So aktualisieren Sie ein Dokument aus der Sammlung: updateOne() Methode von com.mongodb.client.MongoCollection Klasse wird verwendet.

Es folgt das Programm zur Auswahl des ersten Dokuments -

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 
import com.mongodb.client.model.Filters; 
import com.mongodb.client.model.Updates; 

import java.util.Iterator; 
import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class UpdatingDocuments { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 
     
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection 
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection myCollection selected successfully"); 

      collection.updateOne(Filters.eq("id", 1), Updates.set("likes", 150));       
      System.out.println("Document update successfully...");  
      
      // Retrieving the documents after updation 
      // Getting the iterable object
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 

      while (it.hasNext()) {  
         System.out.println(it.next());  
         i++; 
      }     
   }  
}

Beim Kompilieren erhalten Sie mit dem obigen Programm das folgende Ergebnis:

Document update successfully... 
Document {{
   _id = 5967745223993a32646baab8, 
   title = MongoDB, 
   id = 1, 
   description = database, 
   likes = 150, 
   url = http://www.tutorialspoint.com/mongodb/, by = tutorials point
}}

Dokument löschen

Um ein Dokument aus der Sammlung zu löschen, müssen Sie das verwenden deleteOne() Methode der com.mongodb.client.MongoCollection Klasse.

Es folgt das Programm zum Löschen eines Dokuments -

import com.mongodb.client.FindIterable; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase; 
import com.mongodb.client.model.Filters;  

import java.util.Iterator; 
import org.bson.Document; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class DeletingDocuments { 
   
   public static void main( String args[] ) {  
   
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 );
      
      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 

      // Retrieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection");
      System.out.println("Collection sampleCollection selected successfully"); 

      // Deleting the documents 
      collection.deleteOne(Filters.eq("id", 1)); 
      System.out.println("Document deleted successfully...");  
      
      // Retrieving the documents after updation 
      // Getting the iterable object 
      FindIterable<Document> iterDoc = collection.find(); 
      int i = 1; 

      // Getting the iterator 
      Iterator it = iterDoc.iterator(); 

      while (it.hasNext()) {  
         System.out.println("Inserted Document: "+i);  
         System.out.println(it.next());  
         i++; 
      }       
   } 
}

Beim Kompilieren erhalten Sie mit dem obigen Programm das folgende Ergebnis:

Connected to the database successfully 
Collection sampleCollection selected successfully 
Document deleted successfully...

Eine Sammlung löschen

Um eine Sammlung aus einer Datenbank zu löschen, müssen Sie die verwenden drop() Methode der com.mongodb.client.MongoCollection Klasse.

Es folgt das Programm zum Löschen einer Sammlung:

import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoDatabase;  

import org.bson.Document;  
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class DropingCollection { 
   
   public static void main( String args[] ) {  

      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 
      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb");  
      
      // Creating a collection 
      System.out.println("Collections created successfully"); 

      // Retieving a collection
      MongoCollection<Document> collection = database.getCollection("sampleCollection");

      // Dropping a Collection 
      collection.drop(); 
      System.out.println("Collection dropped successfully");
   } 
}

Beim Kompilieren erhalten Sie mit dem obigen Programm das folgende Ergebnis:

Connected to the database successfully 
Collection sampleCollection selected successfully 
Collection dropped successfully

Auflistung aller Sammlungen

Um alle Sammlungen in einer Datenbank aufzulisten, müssen Sie die verwenden listCollectionNames() Methode der com.mongodb.client.MongoDatabase Klasse.

Im Folgenden finden Sie das Programm zum Auflisten aller Sammlungen einer Datenbank:

import com.mongodb.client.MongoDatabase; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoCredential;  

public class ListOfCollection { 
   
   public static void main( String args[] ) {  
      
      // Creating a Mongo client 
      MongoClient mongo = new MongoClient( "localhost" , 27017 ); 

      // Creating Credentials 
      MongoCredential credential; 
      credential = MongoCredential.createCredential("sampleUser", "myDb", 
         "password".toCharArray()); 

      System.out.println("Connected to the database successfully");  
      
      // Accessing the database 
      MongoDatabase database = mongo.getDatabase("myDb"); 
      System.out.println("Collection created successfully"); 
      for (String name : database.listCollectionNames()) { 
         System.out.println(name); 
      } 
   }
}

Beim Kompilieren erhalten Sie mit dem obigen Programm das folgende Ergebnis:

Connected to the database successfully 
Collection created successfully 
myCollection 
myCollection1 
myCollection5

Verbleibende MongoDB-Methoden save(), limit(), skip(), sort() usw. funktionieren wie im nachfolgenden Tutorial beschrieben.

Um MongoDB mit PHP zu verwenden, müssen Sie den MongoDB PHP-Treiber verwenden. Laden Sie den Treiber von der URL herunter . Laden Sie den PHP-Treiber herunter . Stellen Sie sicher, dass Sie die neueste Version herunterladen. Entpacken Sie nun das Archiv und legen Sie php_mongo.dll in Ihrem PHP-Erweiterungsverzeichnis (standardmäßig "ext") ab und fügen Sie der Datei php.ini die folgende Zeile hinzu:

extension = php_mongo.dll

Stellen Sie eine Verbindung her und wählen Sie eine Datenbank aus

Um eine Verbindung herzustellen, müssen Sie den Datenbanknamen angeben. Wenn die Datenbank nicht vorhanden ist, erstellt MongoDB sie automatisch.

Im Folgenden finden Sie das Code-Snippet, mit dem Sie eine Verbindung zur Datenbank herstellen können.

<?php
   // connect to mongodb
   $m = new MongoClient();
	
   echo "Connection to database successfully";
   // select a database
   $db = $m->mydb;
	
   echo "Database mydb selected";
?>

Wenn das Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Connection to database successfully
Database mydb selected

Erstellen Sie eine Sammlung

Im Folgenden finden Sie das Code-Snippet zum Erstellen einer Sammlung:

<?php
   // connect to mongodb
   $m = new MongoClient(); echo "Connection to database successfully"; // select a database $db = $m->mydb; echo "Database mydb selected"; $collection = $db->createCollection("mycol");
   echo "Collection created succsessfully";
?>

Wenn das Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Connection to database successfully
Database mydb selected
Collection created succsessfully

Dokument einfügen

Um ein Dokument in MongoDB einzufügen, insert() Methode wird verwendet.

Es folgt das Code-Snippet zum Einfügen eines Dokuments:

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";
	
   $document = array( "title" => "MongoDB", "description" => "database", "likes" => 100, "url" => "http://www.tutorialspoint.com/mongodb/", "by" => "tutorials point" ); $collection->insert($document);
   echo "Document inserted successfully";
?>

Wenn das Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Document inserted successfully

Alle Dokumente finden

Um alle Dokumente aus der Sammlung auszuwählen, wird die Methode find () verwendet.

Im Folgenden finden Sie das Code-Snippet zur Auswahl aller Dokumente.

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";

   $cursor = $collection->find();
   // iterate cursor to display title of documents
	
   foreach ($cursor as $document) {
      echo $document["title"] . "\n";
   }
?>

Wenn das Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Connection to database successfully
Database mydb selected
Collection selected succsessfully {
   "title": "MongoDB"
}

Aktualisieren Sie ein Dokument

Um ein Dokument zu aktualisieren, müssen Sie die update () -Methode verwenden.

Im folgenden Beispiel aktualisieren wir den Titel des eingefügten Dokuments auf MongoDB Tutorial. Im Folgenden finden Sie das Code-Snippet zum Aktualisieren eines Dokuments.

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";

   // now update the document
   $collection->update(array("title"=>"MongoDB"), array('$set'=>array("title"=>"MongoDB Tutorial")));
   echo "Document updated successfully";
	
   // now display the updated document
   $cursor = $collection->find();
	
   // iterate cursor to display title of documents
   echo "Updated document";
	
   foreach ($cursor as $document) {
      echo $document["title"] . "\n";
   }
?>

Wenn das Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Document updated successfully
Updated document {
   "title": "MongoDB Tutorial"
}

Dokument löschen

Um ein Dokument zu löschen, müssen Sie die Methode remove () verwenden.

Im folgenden Beispiel werden die Dokumente mit dem Titel entfernt MongoDB Tutorial. Es folgt das Code-Snippet zum Löschen eines Dokuments:

<?php
   // connect to mongodb
   $m = new MongoClient();
   echo "Connection to database successfully";
	
   // select a database
   $db = $m->mydb;
   echo "Database mydb selected";
   $collection = $db->mycol;
   echo "Collection selected succsessfully";
   
   // now remove the document
   $collection->remove(array("title"=>"MongoDB Tutorial"),false); echo "Documents deleted successfully"; // now display the available documents $cursor = $collection->find(); // iterate cursor to display title of documents echo "Updated document"; foreach ($cursor as $document) { echo $document["title"] . "\n";
   }
?>

Wenn das Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Connection to database successfully
Database mydb selected
Collection selected succsessfully
Documents deleted successfully

Im obigen Beispiel ist der zweite Parameter vom booleschen Typ und wird für verwendet justOne Bereich remove() Methode.

Verbleibende MongoDB-Methoden findOne(), save(), limit(), skip(), sort() usw. funktioniert genauso wie oben erklärt.

Beziehungen in MongoDB stellen dar, wie verschiedene Dokumente logisch miteinander verknüpft sind. Beziehungen können über modelliert werdenEmbedded und Referencednähert sich. Solche Beziehungen können entweder 1: 1, 1: N, N: 1 oder N: N sein.

Betrachten wir den Fall des Speicherns von Adressen für Benutzer. Ein Benutzer kann also mehrere Adressen haben, wodurch eine 1: N-Beziehung entsteht.

Es folgt die Beispieldokumentstruktur von user Dokument -

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "name": "Tom Hanks",
   "contact": "987654321",
   "dob": "01-01-1991"
}

Es folgt die Beispieldokumentstruktur von address Dokument -

{
   "_id":ObjectId("52ffc4a5d85242602e000000"),
   "building": "22 A, Indiana Apt",
   "pincode": 123456,
   "city": "Los Angeles",
   "state": "California"
}

Modellierung eingebetteter Beziehungen

Beim eingebetteten Ansatz wird das Adressdokument in das Benutzerdokument eingebettet.

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address": [
      {
         "building": "22 A, Indiana Apt",
         "pincode": 123456,
         "city": "Los Angeles",
         "state": "California"
      },
      {
         "building": "170 A, Acropolis Apt",
         "pincode": 456789,
         "city": "Chicago",
         "state": "Illinois"
      }
   ]
}

Dieser Ansatz verwaltet alle zugehörigen Daten in einem einzigen Dokument, wodurch das Abrufen und Verwalten vereinfacht wird. Das gesamte Dokument kann in einer einzigen Abfrage abgerufen werden, z.

>db.users.findOne({"name":"Tom Benzamin"},{"address":1})

Beachten Sie, dass in der obigen Abfrage db und users sind die Datenbank bzw. Sammlung.

Der Nachteil ist, dass das eingebettete Dokument die Lese- / Schreibleistung beeinträchtigen kann, wenn es immer größer wird.

Modellierung referenzierter Beziehungen

Dies ist der Ansatz zum Entwerfen einer normalisierten Beziehung. Bei diesem Ansatz werden sowohl das Benutzer- als auch das Adressdokument separat verwaltet, das Benutzerdokument enthält jedoch ein Feld, das auf das Adressdokument verweistid Feld.

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address_ids": [
      ObjectId("52ffc4a5d85242602e000000"),
      ObjectId("52ffc4a5d85242602e000001")
   ]
}

Wie oben gezeigt, enthält das Benutzerdokument das Array-Feld address_idswelches ObjectIds entsprechender Adressen enthält. Mit diesen ObjectIds können wir die Adressdokumente abfragen und von dort Adressdetails abrufen. Bei diesem Ansatz benötigen wir zwei Abfragen: erstens, um die abzurufenaddress_ids Felder aus user Dokument und zweitens, um diese Adressen abzurufen address Sammlung.

>var result = db.users.findOne({"name":"Tom Benzamin"},{"address_ids":1})
>var addresses = db.address.find({"_id":{"$in":result["address_ids"]}})

Wie im letzten Kapitel der MongoDB-Beziehungen zu sehen ist, verwenden wir das Konzept von, um eine normalisierte Datenbankstruktur in MongoDB zu implementieren Referenced Relationships auch bezeichnet als Manual Referencesin dem wir die ID des referenzierten Dokuments manuell in einem anderen Dokument speichern. In Fällen, in denen ein Dokument Verweise aus verschiedenen Sammlungen enthält, können wir jedoch verwendenMongoDB DBRefs.

DBRefs vs Manuelle Referenzen

Als Beispielszenario, in dem wir DBRefs anstelle von manuellen Verweisen verwenden würden, betrachten Sie eine Datenbank, in der wir verschiedene Arten von Adressen (Privat, Büro, Mailing usw.) in verschiedenen Sammlungen (address_home, address_office, address_mailing usw.) speichern. Nun, wenn auserDas Dokument der Sammlung verweist auf eine Adresse. Außerdem muss angegeben werden, welche Sammlung basierend auf dem Adresstyp untersucht werden soll. In solchen Szenarien, in denen ein Dokument auf Dokumente aus vielen Sammlungen verweist, sollten wir DBRefs verwenden.

Verwenden von DBRefs

Es gibt drei Felder in DBRefs -

  • $ref - Dieses Feld gibt die Sammlung des Dokuments an, auf das verwiesen wird

  • $id - Dieses Feld gibt das Feld _id des Dokuments an, auf das verwiesen wird

  • $db - Dies ist ein optionales Feld und enthält den Namen der Datenbank, in der sich das Dokument befindet, auf das verwiesen wird

Stellen Sie sich ein Beispielbenutzerdokument mit einem DBRef-Feld vor address wie im Code-Snippet gezeigt -

{
   "_id":ObjectId("53402597d852426020000002"),
   "address": {
   "$ref": "address_home", "$id": ObjectId("534009e4d852427820000002"),
   "$db": "tutorialspoint"},
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin"
}

Das address Das DBRef-Feld gibt hier an, dass sich das referenzierte Adressdokument in befindet address_home Sammlung unter tutorialspoint Datenbank und hat eine ID von 534009e4d852427820000002.

Der folgende Code wird dynamisch in der von angegebenen angegebenen Sammlung angezeigt $ref Parameter (address_home in unserem Fall) für ein Dokument mit der ID von $id Parameter in DBRef.

>var user = db.users.findOne({"name":"Tom Benzamin"})
>var dbRef = user.address
>db[dbRef.$ref].findOne({"_id":(dbRef.$id)})

Der obige Code gibt das folgende Adressdokument zurück, das in vorhanden ist address_home Sammlung -

{
   "_id" : ObjectId("534009e4d852427820000002"),
   "building" : "22 A, Indiana Apt",
   "pincode" : 123456,
   "city" : "Los Angeles",
   "state" : "California"
}

In diesem Kapitel erfahren Sie mehr über abgedeckte Abfragen.

Was ist eine abgedeckte Abfrage?

Gemäß der offiziellen MongoDB-Dokumentation ist eine abgedeckte Abfrage eine Abfrage, in der -

  • Alle Felder in der Abfrage sind Teil eines Index.
  • Alle in der Abfrage zurückgegebenen Felder befinden sich im selben Index.

Da alle in der Abfrage vorhandenen Felder Teil eines Index sind, stimmt MongoDB mit den Abfragebedingungen überein und gibt das Ergebnis unter Verwendung desselben Index zurück, ohne tatsächlich in die Dokumente zu schauen. Da Indizes im RAM vorhanden sind, ist das Abrufen von Daten aus Indizes viel schneller als das Abrufen von Daten durch Scannen von Dokumenten.

Abgedeckte Abfragen verwenden

Beachten Sie zum Testen der abgedeckten Abfragen das folgende Dokument in der users Sammlung -

{
   "_id": ObjectId("53402597d852426020000002"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "gender": "M",
   "name": "Tom Benzamin",
   "user_name": "tombenzamin"
}

Wir werden zuerst einen zusammengesetzten Index für die erstellen users Sammlung auf den Feldern gender und user_name mit der folgenden Abfrage -

>db.users.ensureIndex({gender:1,user_name:1})

Dieser Index deckt nun die folgende Abfrage ab:

>db.users.find({gender:"M"},{user_name:1,_id:0})

Das heißt, dass MongoDB für die obige Abfrage keine Datenbankdokumente untersuchen würde. Stattdessen würde es die erforderlichen Daten aus indizierten Daten abrufen, was sehr schnell ist.

Da unser Index nicht enthält _idFeld haben wir es explizit aus der Ergebnismenge unserer Abfrage ausgeschlossen, da MongoDB standardmäßig in jeder Abfrage das Feld _id zurückgibt. Die folgende Abfrage wäre also nicht in dem oben erstellten Index enthalten gewesen -

>db.users.find({gender:"M"},{user_name:1})

Denken Sie zum Schluss daran, dass ein Index eine Abfrage nicht abdecken kann, wenn -

  • Jedes der indizierten Felder ist ein Array
  • Jedes der indizierten Felder ist ein Unterdokument

Das Analysieren von Abfragen ist ein sehr wichtiger Aspekt, um zu messen, wie effektiv das Datenbank- und Indizierungsdesign ist. Wir werden etwas über die häufig verwendeten lernen$explain und $hint Anfragen.

Mit $ EXPLAIN

Das $explainDer Operator bietet Informationen zur Abfrage, zu den in einer Abfrage verwendeten Indizes und zu anderen Statistiken. Dies ist sehr nützlich, wenn Sie analysieren möchten, wie gut Ihre Indizes optimiert sind.

Im letzten Kapitel hatten wir bereits einen Index für die users Sammlung auf Feldern gender und user_name mit der folgenden Abfrage -

>db.users.ensureIndex({gender:1,user_name:1})

Wir werden jetzt verwenden $explain auf die folgende Abfrage -

>db.users.find({gender:"M"},{user_name:1,_id:0}).explain()

Die obige EXPLAIN () - Abfrage gibt das folgende analysierte Ergebnis zurück:

{
   "cursor" : "BtreeCursor gender_1_user_name_1",
   "isMultiKey" : false,
   "n" : 1,
   "nscannedObjects" : 0,
   "nscanned" : 1,
   "nscannedObjectsAllPlans" : 0,
   "nscannedAllPlans" : 1,
   "scanAndOrder" : false,
   "indexOnly" : true,
   "nYields" : 0,
   "nChunkSkips" : 0,
   "millis" : 0,
   "indexBounds" : {
      "gender" : [
         [
            "M",
            "M"
         ]
      ],
      "user_name" : [
         [
            {
               "$minElement" : 1 }, { "$maxElement" : 1
            }
         ]
      ]
   }
}

Wir werden uns nun die Felder in dieser Ergebnismenge ansehen -

  • Der wahre Wert von indexOnly gibt an, dass diese Abfrage die Indizierung verwendet hat.

  • Das cursorFeld gibt den Typ des verwendeten Cursors an. Der BTreeCursor-Typ gibt an, dass ein Index verwendet wurde, und gibt auch den Namen des verwendeten Index an. BasicCursor zeigt an, dass ein vollständiger Scan ohne Verwendung von Indizes durchgeführt wurde.

  • n Gibt die Anzahl der zurückgegebenen Dokumente an.

  • nscannedObjects Gibt die Gesamtzahl der gescannten Dokumente an.

  • nscanned Gibt die Gesamtzahl der gescannten Dokumente oder Indexeinträge an.

$ Hinweis verwenden

Das $hintDer Operator zwingt den Abfrageoptimierer, den angegebenen Index zum Ausführen einer Abfrage zu verwenden. Dies ist besonders nützlich, wenn Sie die Leistung einer Abfrage mit verschiedenen Indizes testen möchten. Die folgende Abfrage gibt beispielsweise den Index für Felder angender und user_name für diese Abfrage verwendet werden -

>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1})

Um die obige Abfrage mit $ EXPLAIN zu analysieren -

>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1}).explain()

Modelldaten für atomare Operationen

Der empfohlene Ansatz zur Aufrechterhaltung der Atomizität besteht darin, alle zugehörigen Informationen zu speichern, die häufig zusammen in einem einzigen Dokument aktualisiert werden embedded documents. Dies würde sicherstellen, dass alle Aktualisierungen für ein einzelnes Dokument atomar sind.

Betrachten Sie das folgende Produktdokument -

{
   "_id":1,
   "product_name": "Samsung S3",
   "category": "mobiles",
   "product_total": 5,
   "product_available": 3,
   "product_bought_by": [
      {
         "customer": "john",
         "date": "7-Jan-2014"
      },
      {
         "customer": "mark",
         "date": "8-Jan-2014"
      }
   ]
}

In dieses Dokument haben wir die Informationen des Kunden, der das Produkt kauft, in das Dokument eingebettet product_bought_byFeld. Wenn ein neuer Kunde das Produkt kauft, prüfen wir zunächst, ob das Produkt noch verfügbar istproduct_availableFeld. Falls verfügbar, reduzieren wir den Wert des Felds product_available und fügen das eingebettete Dokument des neuen Kunden in das Feld product_bought_by ein. Wir werden verwendenfindAndModify Befehl für diese Funktionalität, da das Dokument gleichzeitig durchsucht und aktualisiert wird.

>db.products.findAndModify({ 
   query:{_id:2,product_available:{$gt:0}}, 
   update:{ 
      $inc:{product_available:-1}, $push:{product_bought_by:{customer:"rob",date:"9-Jan-2014"}} 
   }    
})

Unser Ansatz des eingebetteten Dokuments und der Verwendung der findAndModify-Abfrage stellt sicher, dass die Produktkaufinformationen nur aktualisiert werden, wenn das Produkt verfügbar ist. Und die gesamte Transaktion, die sich in derselben Abfrage befindet, ist atomar.

Betrachten Sie im Gegensatz dazu das Szenario, in dem wir möglicherweise die Produktverfügbarkeit und die Informationen darüber, wer das Produkt gekauft hat, separat aufbewahrt haben. In diesem Fall prüfen wir zunächst anhand der ersten Abfrage, ob das Produkt verfügbar ist. In der zweiten Abfrage aktualisieren wir dann die Kaufinformationen. Es ist jedoch möglich, dass zwischen den Ausführungen dieser beiden Abfragen ein anderer Benutzer das Produkt gekauft hat und es nicht mehr verfügbar ist. Ohne dies zu wissen, aktualisiert unsere zweite Abfrage die Kaufinformationen basierend auf dem Ergebnis unserer ersten Abfrage. Dadurch wird die Datenbank inkonsistent, da wir ein Produkt verkauft haben, das nicht verfügbar ist.

Betrachten Sie das folgende Dokument der users Sammlung -

{
   "address": {
      "city": "Los Angeles",
      "state": "California",
      "pincode": "123"
   },
   "tags": [
      "music",
      "cricket",
      "blogs"
   ],
   "name": "Tom Benzamin"
}

Das obige Dokument enthält eine address sub-document und ein tags array.

Indizieren von Array-Feldern

Angenommen, wir möchten Benutzerdokumente anhand der Tags des Benutzers durchsuchen. Zu diesem Zweck erstellen wir einen Index für das Tags-Array in der Sammlung.

Durch das Erstellen eines Index für ein Array werden wiederum separate Indexeinträge für jedes seiner Felder erstellt. In unserem Fall werden beim Erstellen eines Index für das Tags-Array separate Indizes für die Werte Musik, Cricket und Blogs erstellt.

Verwenden Sie den folgenden Code, um einen Index für das Tags-Array zu erstellen:

>db.users.ensureIndex({"tags":1})

Nach dem Erstellen des Index können wir wie folgt im Tag-Feld der Sammlung suchen -

>db.users.find({tags:"cricket"})

Verwenden Sie Folgendes, um zu überprüfen, ob die ordnungsgemäße Indizierung verwendet wird explain Befehl -

>db.users.find({tags:"cricket"}).explain()

Der obige Befehl führte zu "cursor": "BtreeCursor tags_1", was bestätigt, dass die richtige Indizierung verwendet wird.

Indizieren von Unterdokumentfeldern

Angenommen, wir möchten Dokumente basierend auf Stadt-, Bundesland- und PIN-Code-Feldern durchsuchen. Da alle diese Felder Teil des Adressunterdokumentfelds sind, erstellen wir einen Index für alle Felder des Unterdokuments.

Verwenden Sie den folgenden Code, um einen Index für alle drei Felder des Unterdokuments zu erstellen:

>db.users.ensureIndex({"address.city":1,"address.state":1,"address.pincode":1})

Sobald der Index erstellt ist, können wir mithilfe dieses Index nach folgenden Unterdokumentfeldern suchen:

>db.users.find({"address.city":"Los Angeles"})

Denken Sie daran, dass der Abfrageausdruck der Reihenfolge des angegebenen Index folgen muss. Der oben erstellte Index würde also die folgenden Abfragen unterstützen:

>db.users.find({"address.city":"Los Angeles","address.state":"California"})

Es wird auch die folgende Abfrage unterstützt -

>db.users.find({"address.city":"LosAngeles","address.state":"California",
   "address.pincode":"123"})

In diesem Kapitel lernen wir die Indizierungsbeschränkungen und ihre anderen Komponenten kennen.

Zusätzlicher Overhead

Jeder Index nimmt etwas Platz ein und verursacht einen Overhead beim Einfügen, Aktualisieren und Löschen. Wenn Sie Ihre Sammlung also selten für Lesevorgänge verwenden, ist es sinnvoll, keine Indizes zu verwenden.

RAM-Nutzung

Da Indizes im RAM gespeichert sind, sollten Sie sicherstellen, dass die Gesamtgröße des Index die RAM-Grenze nicht überschreitet. Wenn die Gesamtgröße die RAM-Größe erhöht, werden einige Indizes gelöscht, was zu Leistungseinbußen führt.

Abfragebeschränkungen

Die Indizierung kann nicht in Abfragen verwendet werden, die -

  • Reguläre Ausdrücke oder Negationsoperatoren mögen $nin, $nicht usw.
  • Arithmetische Operatoren wie $ mod usw.
  • $ where-Klausel

Daher ist es immer ratsam, die Indexverwendung für Ihre Abfragen zu überprüfen.

Indexschlüsselgrenzen

Ab Version 2.6 erstellt MongoDB keinen Index, wenn der Wert des vorhandenen Indexfelds das Indexschlüssellimit überschreitet.

Einfügen von Dokumenten, die das Indexschlüssellimit überschreiten

MongoDB fügt kein Dokument in eine indizierte Sammlung ein, wenn der indizierte Feldwert dieses Dokuments die Indexschlüsselgrenze überschreitet. Gleiches gilt für die Dienstprogramme mongorestore und mongoimport.

Maximale Bereiche

  • Eine Sammlung kann nicht mehr als 64 Indizes haben.
  • Die Länge des Indexnamens darf nicht länger als 125 Zeichen sein.
  • Ein zusammengesetzter Index kann maximal 31 Felder indizieren.

Wir haben in allen vorherigen Kapiteln die MongoDB-Objekt-ID verwendet. In diesem Kapitel werden wir die Struktur von ObjectId verstehen.

Ein ObjectId ist ein 12-Byte-BSON-Typ mit der folgenden Struktur:

  • Die ersten 4 Bytes repräsentieren die Sekunden seit der Unix-Epoche
  • Die nächsten 3 Bytes sind die Maschinenkennung
  • Die nächsten 2 Bytes bestehen aus process id
  • Die letzten 3 Bytes sind ein zufälliger Zählerwert

MongoDB verwendet ObjectIds als Standardwert von _idFeld jedes Dokuments, das beim Erstellen eines Dokuments generiert wird. Die komplexe Kombination von ObjectId macht alle _id-Felder eindeutig.

Neue Objekt-ID erstellen

Verwenden Sie den folgenden Code, um eine neue ObjectId zu generieren:

>newObjectId = ObjectId()

Die obige Anweisung gab die folgende eindeutig generierte ID zurück:

ObjectId("5349b4ddd2781d08c09890f3")

Anstatt dass MongoDB die ObjectId generiert, können Sie auch eine 12-Byte-ID angeben -

>myObjectId = ObjectId("5349b4ddd2781d08c09890f4")

Zeitstempel eines Dokuments erstellen

Da die _id ObjectId standardmäßig den 4-Byte-Zeitstempel speichert, müssen Sie in den meisten Fällen die Erstellungszeit eines Dokuments nicht speichern. Sie können die Erstellungszeit eines Dokuments mit der Methode getTimestamp abrufen.

>ObjectId("5349b4ddd2781d08c09890f4").getTimestamp()

Dadurch wird die Erstellungszeit dieses Dokuments im ISO-Datumsformat zurückgegeben.

ISODate("2014-04-12T21:49:17Z")

Konvertieren von ObjectId in String

In einigen Fällen benötigen Sie möglicherweise den Wert von ObjectId in einem Zeichenfolgenformat. Verwenden Sie den folgenden Code, um die ObjectId in eine Zeichenfolge zu konvertieren:

>newObjectId.str

Der obige Code gibt das Zeichenfolgenformat der Guid zurück -

5349b4ddd2781d08c09890f3

Gemäß der MongoDB-Dokumentation Map-reduceist ein Datenverarbeitungsparadigma zum Verdichten großer Datenmengen zu nützlichen aggregierten Ergebnissen. MongoDB verwendetmapReduceBefehl für Kartenreduzierungsoperationen. MapReduce wird im Allgemeinen zur Verarbeitung großer Datenmengen verwendet.

MapReduce-Befehl

Es folgt die Syntax des grundlegenden Befehls mapReduce -

>db.collection.mapReduce(
   function() {emit(key,value);},  //map function
   function(key,values) {return reduceFunction}, {   //reduce function
      out: collection,
      query: document,
      sort: document,
      limit: number
   }
)

Die Map-Reduce-Funktion fragt zuerst die Sammlung ab und ordnet dann die Ergebnisdokumente zu, um Schlüssel-Wert-Paare auszugeben, die dann basierend auf den Schlüsseln mit mehreren Werten reduziert werden.

In der obigen Syntax -

  • map ist eine Javascript-Funktion, die einen Wert mit einem Schlüssel abbildet und ein Schlüssel-Wert-Paar ausgibt

  • reduce ist eine Javascript-Funktion, die alle Dokumente mit demselben Schlüssel reduziert oder gruppiert

  • out Gibt den Speicherort des Abfrageergebnisses zur Kartenreduzierung an

  • query Gibt die optionalen Auswahlkriterien für die Auswahl von Dokumenten an

  • sort Gibt die optionalen Sortierkriterien an

  • limit Gibt die optionale maximale Anzahl der zurückzugebenden Dokumente an

Verwenden von MapReduce

Betrachten Sie die folgende Dokumentstruktur zum Speichern von Benutzerbeiträgen. Das Dokument speichert den Benutzernamen des Benutzers und den Status des Beitrags.

{
   "post_text": "tutorialspoint is an awesome website for tutorials",
   "user_name": "mark",
   "status":"active"
}

Jetzt verwenden wir eine mapReduce-Funktion für unsere posts Sammlung, um alle aktiven Beiträge auszuwählen, gruppieren Sie sie anhand des Benutzernamens und zählen Sie dann die Anzahl der Beiträge jedes Benutzers mit dem folgenden Code:

>db.posts.mapReduce( 
   function() { emit(this.user_id,1); }, 
	
   function(key, values) {return Array.sum(values)}, {  
      query:{status:"active"},  
      out:"post_total" 
   }
)

Die obige mapReduce-Abfrage gibt das folgende Ergebnis aus:

{
   "result" : "post_total",
   "timeMillis" : 9,
   "counts" : {
      "input" : 4,
      "emit" : 4,
      "reduce" : 2,
      "output" : 2
   },
   "ok" : 1,
}

Das Ergebnis zeigt, dass insgesamt 4 Dokumente mit der Abfrage übereinstimmten (Status: "aktiv"), die Zuordnungsfunktion 4 Dokumente mit Schlüssel-Wert-Paaren ausgab und schließlich die Reduzierungsfunktion zugeordnete Dokumente mit denselben Schlüsseln in 2 gruppierte.

Verwenden Sie den Suchoperator -, um das Ergebnis dieser mapReduce-Abfrage anzuzeigen.

>db.posts.mapReduce( 
   function() { emit(this.user_id,1); }, 
   function(key, values) {return Array.sum(values)}, {  
      query:{status:"active"},  
      out:"post_total" 
   }
	
).find()

Die obige Abfrage liefert das folgende Ergebnis, das angibt, dass beide Benutzer tom und mark habe zwei Beiträge in aktiven Staaten -

{ "_id" : "tom", "value" : 2 }
{ "_id" : "mark", "value" : 2 }

In ähnlicher Weise können MapReduce-Abfragen verwendet werden, um große komplexe Aggregationsabfragen zu erstellen. Die Verwendung von benutzerdefinierten Javascript-Funktionen nutzt MapReduce, das sehr flexibel und leistungsstark ist.

Ab Version 2.4 unterstützt MongoDB Textindizes für die Suche in Zeichenfolgeninhalten. DasText Search verwendet Stemming-Techniken, um nach bestimmten Wörtern in den Zeichenfolgenfeldern zu suchen, indem Stemming-Stoppwörter wie a, an, the, usw. Derzeit unterstützt MongoDB rund 15 Sprachen.

Aktivieren der Textsuche

Ursprünglich war die Textsuche eine experimentelle Funktion, aber ab Version 2.6 ist die Konfiguration standardmäßig aktiviert. Wenn Sie jedoch die vorherige Version von MongoDB verwenden, müssen Sie die Textsuche mit dem folgenden Code aktivieren:

>db.adminCommand({setParameter:true,textSearchEnabled:true})

Textindex erstellen

Betrachten Sie das folgende Dokument unter posts Sammlung mit dem Beitragstext und seinen Tags -

{
   "post_text": "enjoy the mongodb articles on tutorialspoint",
   "tags": [
      "mongodb",
      "tutorialspoint"
   ]
}

Wir werden einen Textindex für das Feld post_text erstellen, damit wir im Text unserer Beiträge suchen können -

>db.posts.ensureIndex({post_text:"text"})

Verwenden des Textindex

Nachdem wir den Textindex für das Feld post_text erstellt haben, suchen wir nach allen Posts mit dem Wort tutorialspoint in ihrem Text.

>db.posts.find({$text:{$search:"tutorialspoint"}})

Der obige Befehl gab die folgenden Ergebnisdokumente mit dem Wort zurück tutorialspoint in ihrem Beitragstext -

{ 
   "_id" : ObjectId("53493d14d852429c10000002"), 
   "post_text" : "enjoy the mongodb articles on tutorialspoint", 
   "tags" : [ "mongodb", "tutorialspoint" ]
}
{
   "_id" : ObjectId("53493d1fd852429c10000003"), 
   "post_text" : "writing tutorials on mongodb",
   "tags" : [ "mongodb", "tutorial" ] 
}

Wenn Sie alte Versionen von MongoDB verwenden, müssen Sie den folgenden Befehl verwenden:

>db.posts.runCommand("text",{search:" tutorialspoint "})

Die Verwendung der Textsuche verbessert die Sucheffizienz im Vergleich zur normalen Suche erheblich.

Textindex löschen

Um einen vorhandenen Textindex zu löschen, suchen Sie zuerst den Namen des Index mithilfe der folgenden Abfrage:

>db.posts.getIndexes()

Führen Sie den folgenden Befehl aus, nachdem Sie den Namen Ihres Index aus der obigen Abfrage erhalten haben. Hier,post_text_text ist der Name des Index.

>db.posts.dropIndex("post_text_text")

Reguläre Ausdrücke werden häufig in allen Sprachen verwendet, um nach einem Muster oder Wort in einer beliebigen Zeichenfolge zu suchen. MongoDB bietet auch Funktionen für reguläre Ausdrücke für den Abgleich von Zeichenfolgenmustern mithilfe von$regexOperator. MongoDB verwendet PCRE (Perl Compatible Regular Expression) als Sprache für reguläre Ausdrücke.

Im Gegensatz zur Textsuche müssen wir keine Konfiguration oder Befehle ausführen, um reguläre Ausdrücke zu verwenden.

Betrachten Sie die folgende Dokumentstruktur unter posts Sammlung mit dem Beitragstext und seinen Tags -

{
   "post_text": "enjoy the mongodb articles on tutorialspoint",
   "tags": [
      "mongodb",
      "tutorialspoint"
   ]
}

Regex-Ausdruck verwenden

Die folgende Regex-Abfrage sucht nach allen Posts, die Zeichenfolgen enthalten tutorialspoint darin -

>db.posts.find({post_text:{$regex:"tutorialspoint"}})

Die gleiche Abfrage kann auch geschrieben werden als -

>db.posts.find({post_text:/tutorialspoint/})

Verwenden des regulären Ausdrucks mit Groß- und Kleinschreibung wird nicht berücksichtigt

Um die Groß- und Kleinschreibung nicht zu berücksichtigen, verwenden wir die $options Parameter mit Wert $i. Der folgende Befehl sucht nach Zeichenfolgen mit dem Worttutorialspoint, unabhängig von kleineren oder Kapitalfall -

>db.posts.find({post_text:{$regex:"tutorialspoint",$options:"$i"}})

Eines der Ergebnisse dieser Abfrage ist das folgende Dokument, das das Wort enthält tutorialspoint in verschiedenen Fällen -

{
   "_id" : ObjectId("53493d37d852429c10000004"),
   "post_text" : "hey! this is my post on TutorialsPoint", 
   "tags" : [ "tutorialspoint" ]
}

Verwenden von Regex für Array-Elemente

Wir können auch das Konzept der Regex im Array-Feld verwenden. Dies ist besonders wichtig, wenn wir die Funktionalität von Tags implementieren. Wenn Sie also nach allen Posts suchen möchten, deren Tags mit dem Wort "Tutorial" beginnen (entweder Tutorial oder Tutorials oder Tutorialpoint oder Tutorialphp), können Sie den folgenden Code verwenden:

>db.posts.find({tags:{$regex:"tutorial"}})

Abfragen von regulären Ausdrücken optimieren

  • Wenn die Dokumentfelder sind indexedBei der Abfrage werden indizierte Werte verwendet, um mit dem regulären Ausdruck übereinzustimmen. Dies macht die Suche im Vergleich zum Scannen der gesamten Sammlung durch reguläre Ausdrücke sehr schnell.

  • Wenn der reguläre Ausdruck a ist prefix expressionAlle Übereinstimmungen sollen mit bestimmten Zeichenfolgen beginnen. Zum Beispiel, wenn der Regex-Ausdruck ist^tutDann muss die Abfrage nur nach den Zeichenfolgen suchen, die mit beginnen tut.

RockMongo ist ein MongoDB-Verwaltungstool, mit dem Sie Ihren Server, Datenbanken, Sammlungen, Dokumente, Indizes und vieles mehr verwalten können. Es bietet eine sehr benutzerfreundliche Möglichkeit zum Lesen, Schreiben und Erstellen von Dokumenten. Es ähnelt dem PHPMyAdmin-Tool für PHP und MySQL.

RockMongo herunterladen

Sie können die neueste Version von RockMongo hier herunterladen: https://github.com/iwind/rockmongo

RockMongo installieren

Nach dem Herunterladen können Sie das Paket in Ihrem Server-Stammordner entpacken und den extrahierten Ordner in umbenennen rockmongo. Öffnen Sie einen beliebigen Webbrowser und greifen Sie auf zuindex.phpSeite aus dem Ordner rockmongo. Geben Sie admin / admin als Benutzername / Passwort ein.

Arbeiten mit RockMongo

Wir werden uns nun einige grundlegende Operationen ansehen, die Sie mit RockMongo ausführen können.

Neue Datenbank erstellen

Klicken Sie auf, um eine neue Datenbank zu erstellen DatabasesTab. KlickenCreate New Database. Geben Sie im nächsten Bildschirm den Namen der neuen Datenbank ein und klicken Sie aufCreate. Im linken Bereich wird eine neue Datenbank hinzugefügt.

Neue Sammlung erstellen

Um eine neue Sammlung in einer Datenbank zu erstellen, klicken Sie im linken Bereich auf diese Datenbank. Klick auf dasNew CollectionLink oben. Geben Sie den erforderlichen Namen der Sammlung an. Machen Sie sich keine Sorgen über die anderen Felder Is Capped, Size und Max. Klicke aufCreate. Eine neue Sammlung wird erstellt und Sie können sie im linken Bereich sehen.

Neues Dokument erstellen

Um ein neues Dokument zu erstellen, klicken Sie auf die Sammlung, unter der Sie Dokumente hinzufügen möchten. Wenn Sie auf eine Sammlung klicken, werden alle dort aufgelisteten Dokumente in dieser Sammlung angezeigt. Um ein neues Dokument zu erstellen, klicken Sie aufInsertLink oben. Sie können die Daten des Dokuments entweder im JSON- oder Array-Format eingeben und auf klickenSave.

Daten exportieren / importieren

Um Daten einer Sammlung zu importieren / exportieren, klicken Sie auf diese Sammlung und dann auf Export/ImportLink auf der Oberseite. Befolgen Sie die nächsten Anweisungen, um Ihre Daten in ein Zip-Format zu exportieren, und importieren Sie dann dieselbe Zip-Datei, um Daten zurück zu importieren.

GridFSist die MongoDB-Spezifikation zum Speichern und Abrufen großer Dateien wie Bilder, Audiodateien, Videodateien usw. Es ist eine Art Dateisystem zum Speichern von Dateien, aber seine Daten werden in MongoDB-Sammlungen gespeichert. GridFS kann Dateien speichern, die noch größer als die Dokumentgrößenbeschränkung von 16 MB sind.

GridFS unterteilt eine Datei in Blöcke und speichert jeden Datenblock in einem separaten Dokument mit einer maximalen Größe von 255 KB.

GridFS verwendet standardmäßig zwei Sammlungen fs.files und fs.chunksum die Metadaten und die Chunks der Datei zu speichern. Jeder Block wird durch sein eindeutiges _id ObjectId-Feld identifiziert. Die Datei fs.files dient als übergeordnetes Dokument. Dasfiles_id Das Feld im Dokument fs.chunks verknüpft den Block mit dem übergeordneten Block.

Es folgt ein Beispieldokument der Sammlung fs.files -

{
   "filename": "test.txt",
   "chunkSize": NumberInt(261120),
   "uploadDate": ISODate("2014-04-13T11:32:33.557Z"),
   "md5": "7b762939321e146569b07f72c62cca4f",
   "length": NumberInt(646)
}

Das Dokument gibt den Dateinamen, die Blockgröße, das Upload-Datum und die Länge an.

Es folgt ein Beispieldokument des fs.chunks-Dokuments -

{
   "files_id": ObjectId("534a75d19f54bfec8a2fe44b"),
   "n": NumberInt(0),
   "data": "Mongo Binary Data"
}

Hinzufügen von Dateien zu GridFS

Jetzt speichern wir eine MP3-Datei mit GridFS unter Verwendung von putBefehl. Dafür werden wir die verwendenmongofiles.exe Dienstprogramm im Ordner bin des MongoDB-Installationsordners.

Öffnen Sie Ihre Eingabeaufforderung, navigieren Sie zur Datei mongofiles.exe im Ordner bin des MongoDB-Installationsordners und geben Sie den folgenden Code ein:

>mongofiles.exe -d gridfs put song.mp3

Hier, gridfsist der Name der Datenbank, in der die Datei gespeichert wird. Wenn die Datenbank nicht vorhanden ist, erstellt MongoDB automatisch ein neues Dokument im laufenden Betrieb. Song.mp3 ist der Name der hochgeladenen Datei. Um das Dokument der Datei in der Datenbank anzuzeigen, können Sie die Suchabfrage verwenden -

>db.fs.files.find()

Der obige Befehl gab das folgende Dokument zurück:

{
   _id: ObjectId('534a811bf8b4aa4d33fdf94d'), 
   filename: "song.mp3", 
   chunkSize: 261120, 
   uploadDate: new Date(1397391643474), md5: "e4f53379c909f7bed2e9d631e15c1c41",
   length: 10401959 
}

Wir können auch alle in der fs.chunks-Sammlung vorhandenen Chunks anzeigen, die sich auf die gespeicherte Datei mit dem folgenden Code beziehen, wobei die in der vorherigen Abfrage zurückgegebene Dokument-ID verwendet wird:

>db.fs.chunks.find({files_id:ObjectId('534a811bf8b4aa4d33fdf94d')})

In meinem Fall gab die Abfrage 40 Dokumente zurück, was bedeutet, dass das gesamte MP3-Dokument in 40 Datenblöcke aufgeteilt wurde.

Capped collectionssind zirkuläre Sammlungen mit fester Größe, die der Einfügereihenfolge folgen, um eine hohe Leistung beim Erstellen, Lesen und Löschen von Vorgängen zu unterstützen. Mit Rundschreiben bedeutet dies, dass bei Erschöpfung der der Sammlung zugewiesenen festen Größe das älteste Dokument in der Sammlung gelöscht wird, ohne dass explizite Befehle angegeben werden.

Begrenzte Sammlungen beschränken Aktualisierungen der Dokumente, wenn die Aktualisierung zu einer erhöhten Dokumentgröße führt. Da begrenzte Sammlungen Dokumente in der Reihenfolge des Festplattenspeichers speichern, wird sichergestellt, dass die Dokumentgröße die auf der Festplatte zugewiesene Größe nicht erhöht. Mit einer Kappe versehene Sammlungen eignen sich am besten zum Speichern von Protokollinformationen, Cache-Daten oder anderen Daten mit hohem Datenvolumen.

Erstellen einer begrenzten Sammlung

Um eine begrenzte Sammlung zu erstellen, verwenden wir den normalen Befehl createCollection, jedoch mit capped Option als true und Angeben der maximalen Größe der Sammlung in Bytes.

>db.createCollection("cappedLogCollection",{capped:true,size:10000})

Zusätzlich zur Sammlungsgröße können wir auch die Anzahl der Dokumente in der Sammlung mithilfe von begrenzen max Parameter -

>db.createCollection("cappedLogCollection",{capped:true,size:10000,max:1000})

Wenn Sie überprüfen möchten, ob eine Sammlung begrenzt ist oder nicht, verwenden Sie Folgendes isCapped Befehl -

>db.cappedLogCollection.isCapped()

Wenn eine Sammlung vorhanden ist, die Sie in Capped konvertieren möchten, können Sie dies mit dem folgenden Code tun:

>db.runCommand({"convertToCapped":"posts",size:10000})

Dieser Code würde unsere vorhandene Sammlung konvertieren posts zu einer begrenzten Sammlung.

Abfragen der begrenzten Sammlung

Standardmäßig zeigt eine Suchabfrage für eine begrenzte Sammlung die Ergebnisse in der Einfügereihenfolge an. Wenn Sie jedoch möchten, dass die Dokumente in umgekehrter Reihenfolge abgerufen werden, verwenden Sie diesort Befehl wie im folgenden Code gezeigt -

>db.cappedLogCollection.find().sort({$natural:-1})

Es gibt nur wenige andere wichtige Punkte in Bezug auf begrenzte Sammlungen, die es zu beachten gilt -

  • Wir können keine Dokumente aus einer begrenzten Sammlung löschen.

  • In einer begrenzten Sammlung sind keine Standardindizes vorhanden, auch nicht im Feld _id.

  • Beim Einfügen eines neuen Dokuments muss MongoDB nicht nach einem Platz suchen, an dem neues Dokument auf der Festplatte gespeichert werden kann. Das neue Dokument kann blind am Ende der Sammlung eingefügt werden. Dies macht Einfügevorgänge in begrenzten Sammlungen sehr schnell.

  • In ähnlicher Weise gibt MongoDB beim Lesen von Dokumenten die Dokumente in derselben Reihenfolge zurück, in der sie auf der Festplatte vorhanden sind. Dies macht den Lesevorgang sehr schnell.

MongoDB verfügt nicht über sofort einsatzbereite automatische Inkrementierungsfunktionen wie SQL-Datenbanken. Standardmäßig wird die 12-Byte-Objekt-ID für die verwendet_idFeld als Primärschlüssel zur eindeutigen Identifizierung der Dokumente. Es kann jedoch Szenarien geben, in denen das Feld _id möglicherweise einen anderen automatisch inkrementierten Wert als die ObjectId aufweist.

Da dies in MongoDB keine Standardfunktion ist, erreichen wir diese Funktionalität programmgesteuert mithilfe von a counters Sammlung wie in der MongoDB-Dokumentation vorgeschlagen.

Verwenden der Zählersammlung

Folgendes berücksichtigen productsDokument. Wir möchten, dass das Feld _id ein istauto-incremented integer sequence ab 1,2,3,4 bis n.

{
  "_id":1,
  "product_name": "Apple iPhone",
  "category": "mobiles"
}

Erstellen Sie dazu eine counters Sammlung, die den letzten Sequenzwert für alle Sequenzfelder verfolgt.

>db.createCollection("counters")

Jetzt fügen wir das folgende Dokument in die Zählersammlung mit ein productid als sein Schlüssel -

{
  "_id":"productid",
  "sequence_value": 0
}

Das Feld sequence_value Verfolgt den letzten Wert der Sequenz.

Verwenden Sie den folgenden Code, um dieses Sequenzdokument in die Zählersammlung einzufügen -

>db.counters.insert({_id:"productid",sequence_value:0})

Erstellen einer Javascript-Funktion

Jetzt erstellen wir eine Funktion getNextSequenceValueDabei wird der Sequenzname als Eingabe verwendet, die Sequenznummer um 1 erhöht und die aktualisierte Sequenznummer zurückgegeben. In unserem Fall lautet der Sequenznameproductid.

>function getNextSequenceValue(sequenceName){

   var sequenceDocument = db.counters.findAndModify({
      query:{_id: sequenceName },
      update: {$inc:{sequence_value:1}},
      new:true
   });
	
   return sequenceDocument.sequence_value;
}

Verwenden der Javascript-Funktion

Wir werden jetzt die Funktion getNextSequenceValue verwenden, während wir ein neues Dokument erstellen und den zurückgegebenen Sequenzwert als _id-Feld des Dokuments zuweisen.

Fügen Sie zwei Beispieldokumente mit dem folgenden Code ein:

>db.products.insert({
   "_id":getNextSequenceValue("productid"),
   "product_name":"Apple iPhone",
   "category":"mobiles"
})

>db.products.insert({
   "_id":getNextSequenceValue("productid"),
   "product_name":"Samsung S3",
   "category":"mobiles"
})

Wie Sie sehen können, haben wir die Funktion getNextSequenceValue verwendet, um den Wert für das Feld _id festzulegen.

Um die Funktionalität zu überprüfen, rufen wir die Dokumente mit dem Befehl find ab.

>db.products.find()

Die obige Abfrage gab die folgenden Dokumente mit dem automatisch inkrementierten Feld _id zurück:

{ "_id" : 1, "product_name" : "Apple iPhone", "category" : "mobiles"}

{ "_id" : 2, "product_name" : "Samsung S3", "category" : "mobiles" }