In diesem Artikel geht es um die häufig verwendeten Abfragen und Befehle von MongoDB, die von Entwicklern und DBA im täglichen Entwicklungs- und Betriebsleben verwendet werden.

Schnelles Intro

In dieser neuen Ära der intelligenten Technologie werden Daten in großen Mengen generiert, und jede einzelne Information ist für wachsende Branchen gleichermaßen wichtig. Die Benutzer erzeugen strukturierte, halbstrukturierte und unstrukturierte Daten in einer unbegrenzten Menge. Strukturierte Daten umfassen die Speicherung von Daten in Tabellen und Zeilen, während unstrukturierte Daten aus Bildern, Videos und Sprachclips bestehen. Aufgrund des wachsenden Datenvolumens an strukturierten und unstrukturierten Daten entsteht die Notwendigkeit von NoSQL-Datenbanken.

Sie erleichtert den Entwicklern die Erstellung von Schemata und bietet den Datenbankadministratoren eine skalierbare, sichere und schnelle Plattform.

Was ist MongoDB?

MongoDB ist eine dokumentenorientierte, plattformübergreifende und quelloffene NoSQL-Datenbank, die zum Speichern halbstrukturierter Daten verwendet wird und in C geschrieben wurde. Anstelle von Tabellen und Zeilen speichert MongoDB Daten in Schlüssel-Wert-Paaren. Um Entwicklern und Administratoren das Lernen zu erleichtern, finden Sie hier einige der häufig verwendeten MongoDB-Befehle.

Lassen Sie uns anfangen.

Grundlegende Befehle

1. Version prüfen

Mit dem ersten Befehl können Sie die installierte Version des MongoDB-Servers und der Mongo Shell überprüfen. Führen Sie diesen Befehl über das Terminal unter Linux oder die CMD-Eingabeaufforderung unter Windows aus.

mongod --version

C:\Windows\System32>mongod --version
db version v4.2.7
git version: 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
zuweiser: tcmalloc
module: keine
build-Umgebung:
    distmod: 2012plus
    distarch: x86_64
    ziel_arch: x86_64

Wir können auch den Befehl mongod verwenden, um die Version zu überprüfen, wie folgt.

mongo -version

C:\Windows\System32>mongo --version
MongoDB Shell Version v4.2.7
git version: 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
zuweiser: tcmalloc
module: keine
build-Umgebung:
    distmod: 2012plus
    distarch: x86_64
    ziel_arch: x86_64

2. Auflisten der MongoDB-Befehle

Mit diesem Befehl können Sie alle Befehle auflisten, die in MongoDB verwendet werden können. Führen Sie den Befehl in der Mongo Shell aus.

help()

mongo> db.help()
DB-Methoden:
        db.adminCommand(nameOderDocument) - wechselt zur 'admin' db und führt den Befehl aus [ruft einfach db.runCommand(...) auf]
        db.aggregate([pipeline], {options}) - führt eine sammlungslose Aggregation auf dieser Datenbank durch; gibt einen Cursor zurück
        db.auth(benutzername, passwort)
        db.cloneDatabase(fromhost) - funktioniert nur mit MongoDB 4.0 und darunter
        db.commandHelp(name) gibt die Hilfe für den Befehl zurück
        db.copyDatabase(fromdb, todb, fromhost) - funktioniert nur mit MongoDB 4.0 und darunter
        db.createCollection(name, {size: ..., capped: ..., max: ...})
        db.createUser(userDocument)
        db.createView(name, viewOn, [{$operator: {...}}, ...], {viewOptions})
        db.currentOp() zeigt die aktuell ausgeführten Operationen in der Datenbank an
        db.dropDatabase(writeConcern)
        db.dropBenutzer(benutzername)
        db.eval() - veraltet
        db.fsyncLock() Daten auf die Festplatte leeren und Server für Backups sperren
        db.fsyncUnlock() hebt die Sperrung des Servers nach einem db.fsyncLock() auf
        db.getCollection(cname) dasselbe wie db['cname'] oder db.cname
        db.getCollectionInfos([filter]) - gibt eine Liste zurück, die die Namen und Optionen der Sammlungen der db enthält
        db.getCollectionNames()
        db.getLastError() - gibt nur die Fehlermeldung zurück
        db.getLastErrorObj() - gibt das vollständige Statusobjekt zurück
        db.getLogComponents()
        db.getMongo() - liefert das Objekt der Serververbindung
        db.getMongo().setSlaveOk() ermöglicht Abfragen auf einem Replikations-Slave-Server
        db.getName()
        db.getProfilingLevel() - veraltet
        db.getProfilingStatus() - gibt zurück, ob die Profilerstellung eingeschaltet ist und einen langsamen Schwellenwert hat
        db.getReplicationInfo()
        db.getSiblingDB(name) liefert die Datenbank auf demselben Server wie diese
        db.getWriteConcern() - gibt die Schreibberechtigung zurück, die für alle Operationen auf dieser Datenbank verwendet wird, geerbt vom Serverobjekt, falls gesetzt
        db.hostInfo() liefert Details über den Host des Servers
        db.isMaster() prüft den primären Status der Replik
        db.killOp(opid) bricht die aktuelle Operation in der Datenbank ab
        db.listCommands() listet alle db-Befehle auf
        db.loadServerScripts() lädt alle Skripte in db.system.js
        db.logout()
        db.printCollectionStats()
        db.printReplicationInfo()
        db.printShardingStatus()
        db.printSlaveReplicationInfo()
        db.resetFehler()
        db.runCommand(cmdObj) Führt einen Datenbankbefehl aus. Wenn cmdObj ein String ist, wird er zu {cmdObj: 1}
        db.serverStatus()
        db.setLogLevel(level,<Komponente>)
        db.setProfilingLevel(level,slowms) 0=aus 1=langsam 2=alle
        db.setVerboseShell(flag) zusätzliche Informationen in der Shell-Ausgabe anzeigen
        db.setWriteConcern(<Schreibsorg.doc>) - setzt die Schreibsorgfalt für Schreibvorgänge in der Datenbank
        db.shutdownServer()
        db.stats()
        db.unsetWriteConcern(<Schreibsorge>) - hebt die Schreibsorge für Schreibvorgänge in der Datenbank auf
        db.version() - aktuelle Version des Servers
        db.watch() - öffnet einen Change Stream Cursor für eine Datenbank, um über alle Änderungen an ihren Nicht-System-Collections zu berichten.

3. DB-Statistiken

Der folgende Befehl liefert Details zu den Datenbanken sowie zu verschiedenen Sammlungen und zugehörigen Parametern dieser Datenbank.

db.stats()

> db.stats()
{
        "db" : "test",
        "collections" : 0,
        "views" : 0,
        "objects" : 0,
        "avgObjSize" : 0,
        "dataSize" : 0,
        "storageSize" : 0,
        "numExtents" : 0,
        "indexes" : 0,
        "indexSize" : 0,
        "scaleFactor" : 1,
        "fileSize" : 0,
        "fsUsedSize" : 0,
        "fsTotalSize" : 0,
        "ok" : 1
}

4. Neue DB erstellen oder zu bestehender DB wechseln

Dieser einfache Befehl hilft Ihnen, eine neue Datenbank zu erstellen, wenn sie noch nicht existiert, oder zu einer bestehenden Datenbank zu wechseln. In MongoDB ist “test” die Standarddatenbank, so dass Benutzer die “test“-DB verwenden, sobald die Mongo Shell angemeldet ist.

dB_Name verwenden

mongos> use geekFlareDB
zu DB geekFlareDB gewechselt

5. Auflistung aller Datenbanken

Der genannte Befehl wird verwendet, um alle Datenbanken aufzulisten.

dbs anzeigen

mongo> show dbs
admin 0.000GB
config 0.002GB
geekFlareDB 0.000GB
test 0.000GB

6. Prüfen Sie die aktuell verwendete DB

Führen Sie den folgenden Befehl in der Mongo Shell aus, um die aktuell genutzte DB zu sehen.

db

> db
GeekFlare

7. Datenbank löschen

Der angegebene Befehl hilft dem Benutzer, die gewünschte Datenbank zu löschen. Führen Sie den Befehl auf dem MongoDB-Client aus. Bitte stellen Sie sicher, dass Sie die Datenbank auswählen, bevor Sie den Befehl Drop ausführen. Andernfalls wird die Standarddatenbank “test” gelöscht.

db.dropDatabase()

Lassen Sie sich zunächst alle Datenbanken auflisten, wechseln Sie zu einer von ihnen und löschen Sie sie dann

> show dbs
admin 0.000GB
config 0.001GB
lokal 0.000GB
test 0.000GB
training 0.000GB
>
> Training verwenden
gewechselt zu db training
>
> db.dropDatabase()
{ "dropped" : "training", "ok" : 1 }

8. Sammlung erstellen

Sammlungen sind vergleichbar mit Tabellen in RDBMS.

Der Befehl zum Erstellen einer Sammlung besteht aus zwei Parametern. Die Sammlung besteht aus null oder mehr Dokumenten. Der obligatorische Parameter für die Erstellung einer Sammlung ist daher ihr Name und der optionale Parameter kann den Namen der Dokumente, ihre Größe und ihren Index enthalten.

  • Erstellen einer einfachen Sammlung.

Syntax: db.createCollection(Name,Optionen)

Beispiel:

> geekFlare verwenden
wechselte zu db geekFlare
>
> db.createCollection("geekFlareCollection")
{ "ok" : 1 }
>
> Sammlungen anzeigen
geekFlareCollection
  • Erstellen einer Capped Collection

Schränken Sie dabei die Größe und Anzahl der Dokumente ein, die in die Sammlung eingefügt werden sollen. Die Capped Collection hat eine Eigenschaft, mit der die ältesten Dokumente entfernt werden, um Platz für neue Dokumente zu schaffen.

Syntax:

db.createCollection(Name,{capped : true, size : sizeLimit , max : documentLimit })

Beispiel: Erstellen wir eine Capped Collection, fügen wir einen Datensatz ein und rufen ihn ab

> db.createCollection("Login",{capped:true,max:1,size:200})
{ "ok" : 1 }
>
> db.Login.insertMany([{"id":1,status: "Active"},{"id":2,status: "Hold"},{"id":3,status: "Pending"}])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5edc5f4f411247725e75e52e"),
                ObjectId("5edc5f4f411247725e75e52f"),
                ObjectId("5edc5f4f411247725e75e530")
        ]
}
>
> db.Login.find()
{ "_id" : ObjectId("5edc5f4f411247725e75e530"), "id" : 3, "status" : "Pending" }

9. Sammlung verwerfen

Der Befehl Drop Collection ist ähnlich wie DDL in RDBMS. Er erwirbt Sperren für die gewünschte Sammlung bis zur Ausführung des Befehls. Drop Collection entfernt die Sammlung aus der DB zusammen mit allen Indizes, die mit dieser Sammlung verbunden sind. Um die Sammlung zu löschen, ist die Methode drop() erforderlich.

Sie gibt true zurück, wenn das Löschen erfolgreich war und false, wenn ein Fehler auftritt oder die DB nicht existiert.

Syntax: collectionName.drop()

Beispiel:

> geekFlare verwenden
wechselte zu db geekFlare
>
> Sammlungen anzeigen
geekFlareCollection
>
> db.geekFlareCollection.drop()
true
>
> db.geekFlareCollection.drop()
false

CRUD-Operationen bezogen

10. Dokument in Sammlung einfügen

In MongoDB entspricht ein Dokument einem Tupel in einem RDBMS.

Um ein Dokument zu erstellen, wird die Methode insert() verwendet. Die insert()-Methode erstellt ein oder mehrere Dokumente in einer bestehenden Sammlung. Sie erstellt auch eine Sammlung, wenn diese nicht in der DB vorhanden ist. In MongoDB ist das Dokument schemaunabhängig, d.h. es gibt keine Einschränkung bei der Eingabe einer beliebigen Anzahl von Schlüsseln in ein Dokument.

  • Einfügen eines einzelnen Datensatzes

Um einen Datensatz einzufügen, können Sie die Methode insert() oder insertOne() verwenden.

Syntax: collectionName.insertOne({document})

Beispiel:

> db.geekFlareCollection.insertOne( {
 code: "P123", Qty: 200, Status: "Aktiv"
});
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5ed309725429283aee2e134d")
}
  • Mehrere Datensätze einfügen

Um mehrere Datensätze einzufügen, wird eine Liste von Datensätzen an die Methode insert() oder insertMany() übergeben.

Syntax:

collectionName.insertMany([{Dokument1},{Dokument2},{Dokument3}....{Dokumentn}])

Beispiel:

db.geekFlareCollection.insertMany([
... { code: "P1", Qty: 100, Status: "Aktiv"},
... { Code: "P2", Menge: 200, Status: "Aktiv"},
... { Code: "P3", Menge: 0, Status: "Dektiv"}
... ]);
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5edf7b4e18b2c26b9dfe8cac"),
                ObjectId("5edf7b4e18b2c26b9dfe8cad"),
                ObjectId("5edf7b4e18b2c26b9dfe8cae")
        ]
}
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75b8"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75b9"), "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75ba"), "Produkt" : "Joghurt", "Menge" : 30 }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cac"), "code" : "P1", "Qty" : 100, "Status" : "Aktiv" }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cad"), "code" : "P2", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cae"), "code" : "P3", "Qty" : 0, "Status" : "Dektiv" }
>
  • Datensatz im Pulk einfügen

Eine große Anzahl von Dokumenten kann auch geordnet und ungeordnet eingefügt werden, indem Sie die Methoden initializeOrderedBulkOp() und initializeUnorderedBulkOp() ausführen.

Syntax:

var bulk = db.collectionName.initializeUnorderedBulkOp();

bulk.insert({document1} );

bulk.insert({Dokument2} );

bulk.insert({documentn} );

bulk.execute();

Beispiel:

> var bulk = db.geekFlareCollection.initializeUnorderedBulkOp();
> bulk.insert({ code: "P1", Qty: 100, status: "Aktiv"});
> bulk.insert({ code: "P2", Menge: 200, status: "Aktiv"});
> bulk.insert({ Code: "P3", Menge: 0, Status: "Dektiv"});
> bulk.execute();
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 3,
        "nUpserted" : 0,
        "nMatched" : 0,
        "nModified" : 0,
        "nRemoved" : 0,
        "upserted" : [ ]
})
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8caf"), "code" : "P1", "Qty" : 100, "Status" : "Aktiv" }
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8cb0"), "code" : "P2", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8cb1"), "code" : "P3", "Qty" : 0, "status" : "Dektiv" }
>

11. Dokument aus einer Sammlung abrufen

Um nach einem in einer Sammlung gespeicherten Dokument zu suchen, können Sie die find()-Methode verwenden. Der folgende Befehl wird verwendet, um alle Dokumente aus der Sammlung abzurufen.

  • diefind()-Methode kann verwendet werden, um alle in einer Sammlung gespeicherten Dokumente abzurufen.

Syntax: Sammlungsname.find()

Beispiel:

> db.geekFlareCollection.find()
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86ce"), "code" : "P1", "Qty" : 200, "status" : "Aktiv" }
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86cf"), "code" : "P2", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86d0"), "code" : "P3", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"), "code" : "P4", "Qty" : 100, "Status" : "Inaktiv" }
  • die Methodefind({condition}) kann verwendet werden, um nur die gewünschten Dokumente auf der Grundlage einiger Bedingungen aus der Sammlung abzurufen. MongoDB bietet eine Liste von Projektions- und Abfrageoperatoren zum Abrufen von Werten vom Typ BSON.

Syntax: collectionName.find({ condition })

Beispiel:

> db.geekFlareCollection.find({ Qty: { $eq: 100 }});
{ "_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"), "code" : "P4", "Qty" : 100, "Status" : "Inaktiv" }
  • Um nur ein Dokument abzurufen, bietet MongoDB die Methode findOne(). Sie liefert eine formatierte Ausgabe.

Syntax: sammlungsname.findEins()

Beispiel:

> db.geekFlareCollection.findOne();
{ 
	"_id" : ObjectId("5ed31186b6f2c2bb1edb86ce"), 
        "code" : "P1",
	"Qty" : 200, 
	"Status" : "Inaktiv" 
}

12. Verschönern Sie die Retrieval-Ausgabe

Die find() -Methode liefert eine ungeordnete Ausgabe. MongoDB bietet pretty() -Befehle, um die formatierte Ausgabe zu erhalten.

Syntax: Sammlungsname.find().pretty()

Beispiel:

> db.geekFlareCollection.find({ Qty: { $eq: 100 }}).pretty();
{
        "_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"),
        "code" : "P4",
        "Qty" : 100,
        "Status" : "Inaktiv"
}

13. Dokument in einer Sammlung aktualisieren

MongoDB bietet die Methode update(), um neue Werte für vorhandene Schlüssel in Dokumenten zu setzen. Der Befehl update liefert Details zu geänderten und übereinstimmenden Dokumenten. Die Syntax des Update-Befehls lautet:

Syntax: collectionName.update({SchlüsselZumAktualisieren},{BefehlSetzen})

Beispiel:

> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "Produkt" : "Joghurt", "Menge" : 30 }
>
> db.geekFlareCollection.update({"Produkt" : "Flaschen"},{$set : {"Menge": 10}} )
WriteResult({"nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
>
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 10 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "Produkt" : "Joghurt", "Menge" : 30 }
>
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "Produkt" : "Flaschen", "Menge" : 10 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "product" : "Brot", "Qty" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "Produkt" : "Joghurt", "Menge" : 30 }
  • updateOne(): Um ein einzelnes Dokument zu aktualisieren, gibt es die Methode updateOne(). updateOne() liefert die Anzahl der übereinstimmenden und geänderten Dokumente.

Syntax: collectionName.updateOne({SingleKeyToUpdate},{Set Command})

Beispiel:

> db.geekFlareCollection.updateOne({"product" : "bottles"},{$set : {"Qty": 40}} )
{"acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
  • <strong>updateMany()</strong>: Um mehrere Dokumente unter einer bestimmten Bedingung zu aktualisieren, verfügt MongoDB über die Methode updateMany().

Syntax: collectionName.updateMany({filter},{Set Command})

Beispiel:

> db.geekFlareCollection.updateMany( { "Qty" : { $lt: 30 } },{ $set: { "Qty": "Inactive"} } )
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

14. Dokument einer Sammlung löschen

Um ein Dokument zu löschen, verfügt MongoDB über die Methoden deleteOne() und deleteMany(). Die Syntax der delete-Methoden lautet:

  • <strong>deleteOne({Bedingung}) </strong>löscht das einzelne Dokument, das die Löschkriterien erfüllt.

Syntax: collectionName.deleteOne({Löschbedingung})

Beispiel:

> db.geekFlareCollection.deleteOne({"Produkt" : "Brot"})
{ "acknowledged" : true, "deletedCount" : 1 }
  • <strong>deleteMany() </strong>löscht alle Dokumente, die den Löschkriterien entsprechen. Ohne die Löschkriterien löscht deleteMany({condition}) alle Dokumente.

Syntax: collectionName.deleteMany({LöschBedingung})

Beispiel:

> db.geekFlareCollection.deleteMany({"Produkt" : "Flaschen"})
{ "acknowledged" : true, "deletedCount" : 2 }
  • <strong>remove() </strong>Es gibt eine weitere Methode, um alle Dokumente zu löschen, die den Löschkriterien entsprechen. Die Methode remove() nimmt zwei Argumente entgegen, eines ist die Löschbedingung und das andere ist nur ein Flag.

Hinweis: Die Remove-Methode wird in kommenden Versionen veraltet sein.

Syntax: collectionName.remove({LöschBedingung},1)

Beispiel:

> db.geekFlareCollection.remove({"Produkt" : "Flaschen"})
WriteResult({"nRemoved" : 1 })

15. Abrufen von Distinct

Die Methode distinct() wird verwendet, um eindeutige Datensätze zu erhalten.

  • Um eindeutige Datensätze aus einem Feld zu erhalten.

Syntax: collectionName.distinct(field)

Beispiel:

> db.geekFlareCollection.distinct("Produkt")
[ "Käse", "Snacks2", "Snacks3", "Brot", "Ketchup" ]
  • Um unterschiedliche Datensätze aus einem Feld zu erhalten, während Sie die Abfrage spezifizieren.

Syntax: collectionName.distinct(feld,abfrage)

Beispiel:

> db.geekFlareCollection.distinct('product',{"Qty":20})
[ "Snacks3", "Brot" ]

16. Sammlung umbenennen

MongoDB bietet die Methode renameCollection () zum Umbenennen von Sammlungen.

Syntax: collectionName.renameCollection(newCollectionName)

Beispiel:

>db.geekFlareCollection.renameCollection('geekFlareCol')
{ "ok" : 1 }
> Sammlungen anzeigen
geekFlareCol

Indizierung

17. Index auf Dokument erstellen

Indizes sind eine spezielle Datenstruktur, die einen kleinen Teil des Datensatzes einer Sammlung in leicht durchsuchbarer Form speichert. Indizes unterstützen die auf- und absteigende Sortierung von Feldwerten und ermöglichen so eine bessere Leistung beim Abrufen.

MongoDB bietet den Index default_id. Außerdem unterstützt MongoDB die Erstellung von benutzerdefinierten Indizes. MongoDB-Indizes werden auf der Ebene von Sammlungen definiert und bieten Unterstützung für Felder oder Unterfelder eines Dokuments. Die Syntax für die Erstellung des Index lautet :

  • Erstellen Sie einen Index für ein einzelnes Feld.

Syntax: Sammlungsname.createIndex({Schlüssel:1})

Dabei gibt der Schlüssel das Feld an, für das der Index erstellt wird, und 1 steht für aufsteigende Reihenfolge. Um einen Index in absteigender Reihenfolge zu erstellen, kann -1 verwendet werden.

Beispiel:

> db.geekFlareCollection.createIndex({"Produkt" : 1})
{
        "createdCollectionAutomatisch" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
  • Erstellen Sie einen Index für mehrere Felder.

Syntax: collectionName.createIndex({Schlüssel1:1,schlüssel2:1...keyn:1})

Beispiel:

> db.geekFlareCollection.createIndex({"product" : 1, "Qty":-1})
{
        "createdCollectionAutomatisch" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}

18. Index auf Dokument anzeigen

MongoDB bietet die Methode getIndexes(), um alle Indizes aufzulisten, die für ein Dokument erstellt wurden.

Syntax: collectionName.getIndexes()

Beispiel:

> db.geekFlareCollection.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "geekFlareCollection.geekFlareCollection"
        }
]

19. Index aus dem Dokument entfernen

die MethodedropIndex() wird verwendet, um einen einzelnen Index zu löschen, und die Methode dropIndexes() wird verwendet, um mehrere Indizes zu löschen.

  • Einzelnen Index entfernen

Syntax: collectionName.dropIndex({key})

Beispiel:

> db.geekFlareCollection.dropIndex({"product" : 1})
{ "nIndexesWas" : 3, "ok" : 1 }
  • Mehrere Indizes entfernen.

Syntax: collectionName.dropIndexes({key1,key2...,keyN})

Beispiel:

> db.geekFlareCollection.dropIndexes({"product" : 1, "Qty":-1})
{ "nIndexesWas" : 3, "ok" : 1 }

Abrufbezogen

20. Abruf von Dokumenten einschränken

mit der Methodelimit() können Sie die Anzahl der zurückgegebenen Dokumente begrenzen. Die Methode limit() akzeptiert numerische Argumente.

Syntax: collectionName.find().limit(number)

Beispiel:

> db.geekFlareCollection.find().limit(2)
{ "_id" : ObjectId("5ed3c9e7b6f2c2bb1edb8702"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5ed3c9e7b6f2c2bb1edb8703"), "Produkt" : "Brot", "Menge" : 20 }

21. Abruf von Dokumenten überspringen

MongoDB unterstützt die Methode skip(). Diese Methode überspringt die gewünschte Anzahl von Dokumenten. Sie akzeptiert ein numerisches Argument.

Syntax: sammlungsname.find().skip(zahl)

Beispiel:

> db.geekFlareCollection.find().skip(2)
{ "_id" : 3, "Produkt" : "Joghurt", "Menge" : 30 }
> db.geekFlareCollection.find().skip(3)

22. Sortieren des Abrufs von Dokumenten

Die Methode sort() von MongoDB sortiert die Ausgabedokumente entweder in aufsteigender oder absteigender Reihenfolge. Diese Methode akzeptiert den Namen von Schlüsseln mit einer Zahl, um die Sortierreihenfolge festzulegen. 1 wird für aufsteigende Reihenfolge verwendet, während -1 für absteigende Reihenfolge verwendet wird.

Syntax: sammlungsname.find().sort({Schlüssel:1})

Beispiel:

> db.geekFlareCollection.find().sort({"Qty":1})
{ "_id" : 2, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 3, "Produkt" : "Joghurt", "Menge" : 30 }
{ "_id" : 1, "Produkt" : "Flaschen", "Menge" : 100 }

Validierung bezogen

23. Validierung von Dokumenten

Validatoren helfen dabei, die Art der Daten, die in die Dokumente eingefügt werden, einzuschränken. Validatoren werden in einer Sammlung definiert. Bei der Erstellung eines Validators müssen Sie das Schlüsselwort validator und optional die Validierungsebene und die Validierungsaktion verwenden, um den Validierungsmodus anzugeben. Die Dokumentüberprüfung schränkt das Einfügen eines neuen Feldes in das Dokument nicht ein.

Syntax: createCollection("collectionName",{validator:{ fields condition }})

Beispiel:

> db.createCollection("Login",
...  { validator: { $und:
...       [
...          { phone: { $type: "string" } },
...          { email: { $regex: /@flares\.com$/ } },
...          { status: { $in: [ "Registriert", "Unbekannt" ] } }
...       ]
...    }
... } )
{ "ok" : 1 }
>
> db.Login.insert({Telefon:1234})
WriteResult({
        "nInserted" : 0,
        "writeError" : {
                "code" : 121,
                "errmsg" : "Dokument konnte nicht validiert werden"
        }
})
>
> db.Login.insert({Telefon: "1234",E-Mail: "abc@flares.com",Status: "Unbekannt",Modus: "eingeschränkt"})
WriteResult({"nInserted" : 1 })

24. Schema-Validatoren für eine neue Sammlung

Das zusätzliche Schlüsselwort $jsonSchema zusammen mit den zusätzlichen Eigenschaften mit dem Wert False ist erforderlich, um eine Einschränkung auf der Schemaebene vorzunehmen. Es verhindert, dass neue Felder in das Dokument eingefügt werden.

Syntax: createCollection("collectionName",{validator: { $jsonSchema { schema condition } }})

Beispiel:

> db.createCollection("Login", {
... validator: { $jsonSchema: {
... bsonType: "object",
...        "additionalProperties": false,
... required: [ "email" ],
... properties: {
... email: {
... bsonType : "string",
... Muster : "@flares\.com$",
... description: "String entspricht dem angegebenen Ausdruck"
...          },
... Status: {
... enum: [ "Registriert", "Ungültig" ],
... description: "Status muss innerhalb der enum-Werte liegen"
...          }
...       }
...    } },
... } )
{ "ok" : 1 }
>
> db.Login.insert({email: "abc@flares.com"})
WriteResult({
        "nInserted" : 0,
        "writeError" : {
                "code" : 121,
                "errmsg" : "Dokument konnte nicht validiert werden"
        }
})

25. Aktualisieren oder Erstellen von Schema-Validatoren für eine bestehende Sammlung

Ein Validator kann für eine bestehende Sammlung mit collMod erstellt werden

Syntax: runCommand({collMod: "collectionName",validator:{schema condition}})

Beispiel: 

> db.runCommand( {
collMod: "Login",
   validator: { $jsonSchema: {
       bsonType: "object",
 "additionalProperties": false,
      required: [ "email", "status" ],
      properties: {
         email: {
            bsonType : "string",
            muster : "@flares\.com$",
            description: "String entspricht dem angegebenen Ausdruck"
         },
         status: {
            enum: [ "registriert", "ungültig" ],
            description: "Status muss innerhalb der enum-Werte liegen"
         }
      }
   } },
      validationAction: "Fehler",
         validationLevel: "strict"
} )
{ "ok" : 1 }

26. Schema-Validatoren für eine bestehende Sammlung entfernen

Um Schemavalidatoren zu entfernen, müssen Sie <strong>validationLevel</strong> auf off setzen.

Syntax: runCommand({collMod: "collectionName",validator:{ },validationLevel:off})

Beispiel:

> db.runCommand({
   collMod: "Login",
   validator:{},
   validationLevel: "off"
})
{ "ok" : 1 }
>
> db.Login.insert({"email": "abc"})
WriteResult({ "nInserted" : 1 })

27. Nach Validatoren für eine bestehende Sammlung suchen

Führen Sie den folgenden Befehl aus, um zu prüfen, ob die vorhandene Sammlung über Schemavalidatoren verfügt. Ohne Angabe des Sammlungsnamens liefert die Methode db.getCollectionInfos() Details zu den Prüfern für alle Sammlungen in einer DB.

Syntax: getCollectionInfos({Name : "Sammlungsname"})

Beispiel:

> db.getCollectionInfos({Name: "Login"})
[
        {
                "name" : "Anmeldung",
                "type" : "Sammlung",
                "Optionen" : {
                        "validator" : {
                                "email" : {
                                        "$regex" : /@flares\.com$/
                                }
                        }
                },
                "info" : {
                        "readOnly" : false,
                        "uuid" : UUID("646674f6-4b06-466d-93b0-393b5f5cb4ff")
                },
                "idIndex" : {
                        "v" : 2,
                        "key" : {
                                "_id" : 1
                        },
                        "name" : "_id_",
                        "ns" : "geekFlareDB.Login"
                }
        }
]

Cursors bezogen

28. Cursor in MongoDB

Der Cursor ist ein Zeiger zur Iteration über die Ergebnismenge. MongoDB verwendet die Methoden <strong>hasNext()</strong> und <strong>forEach()</strong> für die Iteration. Wir haben eine Liste von Cursor-Methoden erstellt.

Beispiele:

> var newCursor=db.geekFlareCollection.find()
> newCursor.forEach(printjson)
{ "_id" : 1, "product" : "bottles", "Qty" : 100 }
{ "_id" : 2, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 3, "Produkt" : "Joghurt", "Menge" : 30 }
>
> var newCursor1=db.geekFlareCollection.find()
> while(newCursor1.hasNext()){ printjson(newCursor1.next())}
{ "_id" : 1, "product" : "bottles", "Qty" : 100 }
{ "_id" : 2, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 3, "Produkt" : "Joghurt", "Menge" : 30

Dienstprogramm

29. Erstellen einer Datenbanksicherung

das Dienstprogrammmongodump wird verwendet, um den Inhalt der MongoDB-Datenbank als Backup zu exportieren. Dieser Befehl wird über die Systemkonsole und nicht über die Mongo-Shell ausgeführt. Er erzeugt eine binäre Sicherung zusammen mit Metadaten-Informationen.

Syntax:

mongodump --db dbName --out outFile --host "IP:PORT" --username <user> --password <pass>

Beispiel:

C:\mongodb\dump>mongodump --db geekFlareDB --out "C:\mongodb\dump" --host "127.0.0.1:27017"
2020-06-02T12:26:34.428 0530 schreibt geekFlareDB.myTable nach
2020-06-02T12:26:34.430 0530 schreibt geekFlareDB.geekFlareCollection nach
2020-06-02T12:26:34.430 0530 schreibe geekFlareDB.mCollection nach
2020-06-02T12:26:34.433 0530 schreibe geekFlareDB.users nach
2020-06-02T12:26:34.434 0530 Dumping von geekFlareDB.myTable abgeschlossen (2 Dokumente)
2020-06-02T12:26:34.434 0530 geekFlareDB.geekFlareCollection dumpen (4 Dokumente)
2020-06-02T12:26:34.435 0530 geekFlareDB.contacts2 schreiben in
2020-06-02T12:26:34.435 0530 Schreiben von geekFlareDB.Login nach
2020-06-02T12:26:34.436 0530 Dumping von geekFlareDB.mCollection abgeschlossen (2 Dokumente)
2020-06-02T12:26:34.437 0530 geekFlareDB.users entladen (1 Dokument)
2020-06-02T12:26:34.437 0530 erledigt geekFlareDB.Login entladen (0 Dokumente)
2020-06-02T12:26:34.438 0530 Abzug von geekFlareDB.contacts2 durchgeführt (0 Dokumente)

30. Datenbank aus Backup wiederherstellen

Das Dienstprogramm <strong>mongorestore</strong> wird verwendet, um die von mongodump erzeugten Binärdaten wiederherzustellen.

Syntax: mongorestore --db newDB "pathOfOldBackup"

Beispiel:

C:\Benutzer\asad.ali>mongorestore --db geekFlareNew "C:\mongodb\dump\geekFlare" --host "127.0.0.1:27017"
2020-06-09T15:49:35.147 0530 Die Args --db und --collection sollten nur bei der Wiederherstellung aus einer BSON-Datei verwendet werden. Andere Verwendungen sind veraltet und werden in Zukunft nicht mehr existieren; verwenden Sie stattdessen --nsInclude
2020-06-09T15:49:35.148 0530 Erstellen einer Liste von Sammlungen zur Wiederherstellung aus dem Verzeichnis C:\mongodb\dump\geekFlare
2020-06-09T15:49:35.152 0530 Lesen der Metadaten für geekFlareNew.geekFlareCollection von C:\mongodb\dump\geekFlare\geekFlareCollection.metadata.json
2020-06-09T15:49:35.321 0530 Wiederherstellung von geekFlareNew.geekFlareCollection von C:\mongodb\dump\geekFlare\geekFlareCollection.bson
2020-06-09T15:49:35.461 0530 keine Indizes zum Wiederherstellen
2020-06-09T15:49:35.462 0530 Wiederherstellung von geekFlareNew.geekFlareCollection abgeschlossen (3 Dokumente, 0 Fehlschläge)
2020-06-09T15:49:35.467 0530 3 Dokument(e) erfolgreich wiederhergestellt. 0 Dokument(e) konnte(n) nicht wiederhergestellt werden.

31. Sammlungen exportieren

Um den Inhalt einer Sammlung in eine Datei (JSON oder CSV) zu exportieren, wurde das Dienstprogramm mongoexport bereitgestellt. Verwenden Sie zum Ausführen dieses Befehls das Systemterminal.

  • Exportieren Sie eine einzelne Sammlung in eine Datei.

Syntax: mongoexport --db dbName --collection collectionName --out outputFile

Beispiel:

C:\mongodb\Neuer Ordner>mongoexport --db geekFlareDB --collection geekFlareCol --out outFile.json
2020-06-06T19:02:29.994 0530 verbunden mit: mongodb://localhost/
2020-06-06T19:02:30.004 0530 exportiert 6 Datensätze
  • Exportieren Sie ein bestimmtes Feld aus der Sammlung in eine Datei.

Syntax: mongoexport --db dbName --collection collectionName --out outputFile --fields fieldname

Beispiel:

C:\mongodb\Neuer Ordner>mongoexport --db geekFlareDB --collection geekFlareCol --out outFile.json --fields product
2020-06-06T19:05:22.994 0530 verbunden mit: mongodb://localhost/
2020-06-06T19:05:23.004 0530 exportiert 6 Datensätze

32. Sammlungen importieren

Um Daten aus einer Datei (CSV oder JSON) zu importieren, können Sie das Befehlszeilentool mongoimport verwenden.

Syntax: mongoimport --db dbName --collection collectionName --file inputFile

C:\Users\asad.ali>mongoimport --db geekFlareDB --collection geekFlareNew --file outFile.json
2020-06-09T14:52:53.655 0530 verbunden mit: mongodb://localhost/
2020-06-09T14:52:53.924 0530 6 Dokument(e) erfolgreich importiert. 0 Dokument(e) konnte(n) nicht importiert werden.

Replik bezogen

Replikation ist etwas anderes als Sharding. Sehen Sie sich diese Anleitung zur Implementierung von Sharding an.

33. MongoDB Replikation

Die Replikation ist ein Prozess zur Synchronisierung von Daten auf mehreren Servern. Sie verhindert Datenverluste aufgrund von Hardware- oder Softwarefehlern. MongoDB erreicht die Replikation mit Hilfe von Replikatsätzen. Das Replikatset besteht aus primären und sekundären Mongo-Datensätzen im Cluster.

Der primäre Datensatz akzeptiert alle Schreiboperationen und der sekundäre Datensatz liest vom primären. Mindestens 3 Datensätze sind in einem Mongo-Replikatsatz erforderlich. Der folgende Prozess ist erforderlich, um ein Replikatset einzurichten:

  • Starten Sie den Mongo-Server mit der Option replset auf mindestens 3 Knoten.

mongod --port 27017 --dbpath C:\data\data1 --replSet rs0 --oplogSize 128

mongod --port 27018 --dbpath C:\data\data1 --replSet rs0 --oplogSize 128

mongod --port 27019 --dbpath C:\data\data1 --replSet rs0 --oplogSize 128

  • Initialisieren Sie das Replikatset.

rs.initiate( { _id : "rs0", members: [ { _id: 0, host: "IP:27017" }, { _id: 1, host: "IP:27018" }, { _id: 2, Gastgeber: "IP:27019" } ] })

> rs.initiate( {
...    _id : "rs0",
... members: [
...   { _id: 0, host: "localhost:27017" },
...   { _id: 1, Rechner: "localhost:27018" },
...   { _id: 2, Rechner: "localhost:27019" }
...    ]
... })
{
        "ok" : 1,
        "$clusterTime" : {
                "clusterTime" : Zeitstempel(1591089166, 1),
                "Signatur" : {
                        "hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        },
        "operationTime" : Zeitstempel(1591089166, 1)
}

34. Prüfen Sie den Status der Replikation

Führen Sie den folgenden Befehl vom primären Replikationsknoten aus, um vollständige Informationen über das Replikationsset zu erhalten.

rs.conf()

rs.status()

rs0:PRIMARY> rs.conf()
{
        "_id" : "rs0",
        "version" : 2,
        "protocolVersion" : NumberLong(1),
        "writeConcernMajorityJournalDefault" : true,
        "members" : [
                {
                        "_id" : 0,
                        "host" : "localhost:27017",
                        "arbiterOnly" : false,
                        "buildIndexes" : true,
                        "hidden" : false,
                        "priority" : 1,
                        "tags" : {

                        },
                        "slaveDelay" : NumberLong(0),
                        "Stimmen" : 1
                },
                {
                        "_id" : 1,
                        "host" : "localhost:27018",
                        "arbiterOnly" : false,
                        "buildIndexes" : true,
                        "hidden" : false,
                        "priority" : 1,
                        "tags" : {

                        },
                        "slaveDelay" : NumberLong(0),
                        "Stimmen" : 1
                },
                {
                        "_id" : 2,
                        "host" : "localhost:27019",
                        "arbiterOnly" : false,
                        "buildIndexes" : true,
                        "hidden" : false,
                        "priority" : 1,
                        "tags" : {

                        },
                        "slaveDelay" : NumberLong(0),
                        "Stimmen" : 1
                },
                {
                        "_id" : 3,
                        "host" : "localhost:27016",
                        "arbiterOnly" : false,
                        "buildIndexes" : true,
                        "hidden" : false,
                        "priority" : 1,
                        "tags" : {

                        },
                        "slaveDelay" : NumberLong(0),
                        "Stimmen" : 1
                }
        ],
        "Einstellungen" : {
                "chainingAllowed" : true,
                "heartbeatIntervalMillis" : 2000,
                "heartbeatTimeoutSecs" : 10,
                "electionTimeoutMillis" : 10000,
                "catchUpTimeoutMillis" : -1,
                "catchUpTakeoverDelayMillis" : 30000,
                "getLastErrorModes" : {

                },
                "getLastErrorDefaults" : {
                        "w" : 1,
                        "wtimeout" : 0
                },
                "replicaSetId" : ObjectId("5ed6180d01a39f2162335de5")
        }
}

35. Neue MongoDB-Instanz zu einem Replikatset hinzufügen

Starten Sie den primären MongoDB-Client und führen Sie den folgenden Befehl aus

Syntax: rs.add("hostname:port")

Beispiel:

rs0:PRIMARY> rs.add("localhost:27016")
{
        "ok" : 1,
        "$clusterTime" : {
                "clusterTime" : Zeitstempel(1591094195, 1),
                "Signatur" : {
                        "hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        },
        "operationTime" : Zeitstempel(1591094195, 1)
}

36. Vorhandene MongoDB-Instanz aus dem Replikatset entfernen

Mit dem folgenden Befehl wird der erforderliche sekundäre Host aus dem Replikatset entfernt.

Syntax: rs.remove("localhost:27017")

Beispiel:

rs0:PRIMARY> rs.remove("localhost:27016")
{
        "ok" : 1,
        "$clusterTime" : {
                "clusterTime" : Zeitstempel(1591095681, 1),
                "Signatur" : {
                        "hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        },
        "operationTime" : Zeitstempel(1591095681, 1)
}
rs0:PRIMARY>

37. Primäres als sekundäres Replikatset erstellen

MongoDB bietet einen Befehl, mit dem Sie das primäre Replikat zu einem sekundären Replikatset machen können.

Syntax: rs.stepDown( stepDownSecs , secondaryCatchupSecs )

Beispiel:

rs0:PRIMARY> rs.stepDown(12)
{
        "ok" : 1,
        "$clusterTime" : {
                "clusterTime" : Zeitstempel(1591096055, 1),
                "Signatur" : {
                        "hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        },
        "operationTime" : Zeitstempel(1591096055, 1)
}
rs0:SECONDARY>

38. Prüfen Sie den Replikationsabstand zwischen Primär- und Sekundärserver

Mit dem folgenden Befehl können Sie den Replikationsrückstand zwischen allen Replikaten des primären Systems überprüfen.

Syntax: rs.printSlaveReplicationInfo()

Beispiel:

rs0:PRIMARY> rs.printSlaveReplicationInfo()
quelle: localhost:27018
        syncedTo: Tue Jun 02 2020 16:14:04 GMT 0530 (Indische Standardzeit)
        0 Sekunden (0 Stunden) hinter dem Primärserver
quelle: localhost:27019
        syncedTo: Thu Jan 01 1970 05:30:00 GMT 0530 (Indische Standardzeit)
        1591094644 secs (441970.73 hrs) hinter der primären
quelle: localhost:27016
        syncedTo: Tue Jun 02 2020 16:14:04 GMT 0530 (Indische Standardzeit)
        0 Sekunden (0 Stunden) hinter der Primärquelle
rs0:PRIMÄR>

Transaktionen bezogen

39. Transaktionen in MongoDB

MongoDB unterstützt ACID-Eigenschaften für Transaktionen von Dokumenten.

Um eine Transaktion zu starten, ist eine Sitzung erforderlich, und um Änderungen in der Datenbank zu speichern, ist eine Übergabe erforderlich. Transaktionen werden auf Replikat-Sets oder Mangos unterstützt. Sobald die Sitzung erfolgreich übertragen wurde, sind die in der Sitzung durchgeführten Operationen auch außerhalb der Sitzung sichtbar.

  • Sitzung starten

Syntax: session =db.getMongo().startSession()

  • Transaktion starten,

Syntax: session.startTransaction()

  • Transaktion abschließen

Syntax: session.commitTransaction()

Beispiel:

Lassen Sie uns eine Sitzung erstellen, die Transaktion starten, einige Einfügungen/Aktualisierungen vornehmen und dann die Transaktion übertragen.

rs0:PRIMARY> session = db.getMongo().startSession()
sitzung { "id" : UUID("f255a40d-81bd-49e7-b96c-9f1083cb4a29") }
rs0:PRIMARY> session.startTransaction()
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.insert([
... {_id: 4 , produkt: "Ketchup"},
... {_id: 5 , Produkt: "Käse"}
... ]);
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 2,
        "nUpserted" : 0,
        "nMatched" : 0,
        "nModified" : 0,
        "nRemoved" : 0,
        "upserted" : [ ]
})
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.find()
{ "_id" : 1, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 2, "Produkt" : "Flaschen", "Menge" : 100 }
{ "_id" : 3, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 4, "Produkt" : "Ketchup" }
{ "_id" : 5, "produkt" : "käse" }
rs0:PRIMARY> db.geekFlareCollection.find()
{ "_id" : 1, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 2, "Produkt" : "Flaschen", "Menge" : 100 }
{ "_id" : 3, "Produkt" : "Brot", "Menge" : 20 }
rs0:PRIMARY> session.commitTransaction()
rs0:PRIMARY> db.geekFlareCollection.find()
{ "_id" : 1, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 2, "Produkt" : "Flaschen", "Menge" : 100 }
{ "_id" : 3, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 4, "Produkt" : "Ketchup" }
{ "_id" : 5, "produkt" : "käse" }
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.find()
{ "_id" : 1, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 2, "Produkt" : "Flaschen", "Menge" : 100 }
{ "_id" : 3, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 4, "Produkt" : "Ketchup" }
{ "_id" : 5, "Produkt" : "Käse" }

40. Einzelne Dokumententransaktionen Konflikt

Wenn zwei Transaktionen versuchen, dasselbe Dokument zu aktualisieren, gibt MongoDB einen Schreibkonflikt-Fehler aus.

  • session1.startTransaction()
  • session2.startTransaction()

Führen Sie eine Einfügung/Aktualisierung in Session1 und anschließend in Session2 durch. Beobachten Sie nun den Fehler im folgenden Beispiel

Beispiel:

rs0:PRIMARY> session1.startTransaction()
rs0:PRIMARY> session2.startTransaction()
rs0:PRIMARY> session1.getDatabase("geekFlareDB").geekFlareCollection.update({_id:3},{$set:{ product: "Bread" }})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
rs0:PRIMARY> session2.getDatabase("geekFlareDB").geekFlareCollection.update({_id:3},{$set:{ product: "Snacks" }})
WriteCommandError({
        "errorLabels" : [
                "TransientTransactionError"
        ],
        "operationTime" : Zeitstempel(1591174593, 1),
        "ok" : 0,
        "errmsg" : "WriteConflict",
        "code" : 112,
        "codeName" : "WriteConflict",
        "$clusterTime" : {
                "clusterTime" : Zeitstempel(1591174593, 1),
                "signature" : {
                        "hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
})
rs0:PRIMARY>

41. Multi-Dokument-Transaktionen

MongoDB unterstützt Transaktionen mit mehreren Dokumenten in einer einzigen Sitzung.

  • db.getMongo().startTransaction()

Einfügen/Aktualisieren mehrerer Dokumente durchführen

  • session.commitTransaction()

Beispiel:

rs0:PRIMARY> var session = db.getMongo().startSession()
rs0:PRIMARY> session.startTransaction()
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.update({_id:3},{$set:{ product: "Snacks3" }})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 0 })
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.update({_id:2},{$set:{ product: "Snacks2" }})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 0 })
rs0:PRIMARY> session.commitTransaction()
rs0:PRIMARY> db.geekFlareCollection.find()
{ "_id" : 1, "Produkt" : "Brot", "Menge" : 20 }
{ "_id" : 2, "Produkt" : "Snacks2", "Menge" : 100 }
{ "_id" : 3, "Produkt" : "Snacks3", "Menge" : 20 }
{ "_id" : 4, "Produkt" : "Ketchup" }
{ "_id" : 5, "Produkt" : "Käse" }
rs0:PRIMARY>

42. Profiling in MongoDB

Profiling hilft bei der Protokollierung langsamer Abfragen in der system.profile-Sammlung. Profiler-Level und Sample-Rate definieren den Prozentsatz der Abfragen, die in der system.profile -Sammlung protokolliert werden.

  • Profiling-Level einstellen/abrufen

Syntax:

db.setProfilingLevel(profilingLevel,{"slowms":time, "sampleRate":LoggingPercentage})

> db.setProfilingLevel(2,{"slowms":1, "sampleRate":1})
{"was" : 1, "slowms" : 1, "sampleRate" : 0.5, "ok" : 1 }
>
> db.getProfilingLevel()
2
  • Profiling-Status abrufen

Syntax: db.getProfilingStatus()

> db.getProfilingStatus()
{ "was" : 2, "slowms" : 1, "sampleRate" : 1 }
  • Um die Profilerstellung auf Ebene der MongoDB-Instanz zu aktivieren, starten Sie die Instanz mit Profiler-Informationen oder fügen Sie Profiler-Details in der Konfigurationsdatei hinzu.

Syntax:

mongod --profile <Level> --slowms <time> --slowOpSampleRate <%Logging>

Beispiel:

C:\Windows\System32>mongod --port 27017 --dbpath C:\data\data1 --profile 1 --slowms 25 --slowOpSampleRate 0.5
2020-06-09T02:34:41.110-0700 I CONTROL [ <x>main]</x> Automatisches Deaktivieren von TLS 1.0, um TLS 1.0 zu aktivieren, geben Sie --sslDisabledProtocols 'none' an
2020-06-09T02:34:41.113-0700 W ASIO [ <x>main</x> ] Beim Starten von NetworkInterface wurde kein TransportLayer konfiguriert
2020-06-09T02:34:41.113-0700 I CONTROL [ <x><x><x>initandlisten]</x></x></x> MongoDB startet : pid=22604 port=27017 dbpath=C:\data\data1 64-bit host=MCGL-4499
2020-06-09T02:34:41.114-0700 I CONTROL [ <x><x><x>initandlisten]</x></x></x> targetMinOS: Windows 7/Windows Server 2008 R2
2020-06-09T02:34:41.116-0700 I CONTROL [ <x><x><x>initandlisten]</x></x></x> db version v4.2.7
2020-06-09T02:34:41.116-0700 I CONTROL [ <x><x><x>initandlisten]</x></x></x> git version: 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212

43. MongoDB Explain()

Die MongoDB-Methode Explain () liefert Statistiken und Informationen, um einen erfolgreichen Plan auszuwählen und ihn bis zum Ende auszuführen. Sie gibt die Ergebnisse entsprechend dem Ausführlichkeitsplanzurück .

Syntax: collectionName.explain("VerbosityName")

Um die Methode explain() auszuführen, erstellen Sie zunächst eine Verbosity und führen dann die Methode explain() aus. Sehen Sie sich das folgende Beispiel an, in dem diese Schritte ausgeführt wurden.

Beispiel:

> db.runCommand(
...    {
... explain: { count: "product", query: { Qty: { $gt: 10 } } },
... Ausführlichkeit: "executionStats"
...    }
... )
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test.product",
                "indexFilterSet" : false,
                "winningPlan" : {
                        "stage" : "COUNT",
                        "inputStage" : {
                                "stage" : "EOF"
                        }
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 0,
                "executionTimeMillis" : 47,
                "totalKeysExamined" : 0,
                "totalDocsExamined" : 0,
                "executionStages" : {
                        "stage" : "COUNT",
                        "nReturned" : 0,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 1,
                        "advanced" : 0,
                        "needTime" : 0,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "nCounted" : 0,
                        "nSkipped" : 0,
                        "inputStage" : {
                                "stage" : "EOF",
                                "nReturned" : 0,
                                "executionTimeMillisEstimate" : 0,
                                "works" : 0,
                                "advanced" : 0,
                                "needTime" : 0,
                                "needYield" : 0,
                                "saveState" : 0,
                                "restoreState" : 0,
                                "isEOF" : 1
                        }
                }
        },
        "serverInfo" : {
                "host" : "MCGL-4499",
                "port" : 27017,
                "version" : "4.2.7",
                "gitVersion" : "51d9fe12b5d19720e72dcd7db0f2f17dd9a19212"
        },
        "ok" : 1
}
>
> var expv = db.geekFlareCol.explain("executionStats")
> expv.find( { Produkt: "Brot"} )
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "geekFlareDB.geekFlareCol",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "product" : {
                                "$eq" : "Brot"
                        }
                },
                "winningPlan" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "product" : {
                                        "$eq" : "Brot"
                                }
                        },
                        "Richtung" : "vorwärts"
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 2,
                "executionTimeMillis" : 0,
                "totalKeysExamined" : 0,
                "totalDocsExamined" : 6,
                "executionStages" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "product" : {
                                        "$eq" : "Brot"
                                }
                        },
                        "nReturned" : 2,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 8,
                        "advanced" : 2,
                        "needTime" : 5,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "direction" : "vorwärts",
                        "docsExamined" : 6
                }
        },
        "serverInfo" : {
                "host" : "MCGL-4499",
                "port" : 27017,
                "version" : "4.2.7",
                "gitVersion" : "51d9fe12b5d19720e72dcd7db0f2f17dd9a19212"
        },
        "ok" : 1
}
>

Zugriffskontrolle

44. Zugriffskontrolle in MongoDB

Die Zugriffskontrollfunktionen ermöglichen den Authentifizierungszugriff auf bestehende Benutzer. Um die Zugriffskontrolle zu aktivieren, müssen Sie einen Benutzer mit der Rolle admin in der DB admin anlegen.

  • Verbinden Sie die DB ohne Authentifizierung.
  • Wechseln Sie zur Datenbank

admin verwenden

  • Erstellen Sie einen Benutzer wie unten

db.createUser( {user: "UserAdmin", pwd: "password" ,role: [adminRole])

Beispiel:

db.createUser(
...   {
... Benutzer: "AdminBenutzer",
... pwd: passwordPrompt(),
... roles: [ { role: "userAdminAnyDatabase", db: "admin" }, "readWriteAnyDatabase" ]
...   }
... )
Geben Sie das Passwort ein:
Erfolgreich hinzugefügter Benutzer: {
        "user" : "AdminUser",
        "roles" : [
                {
                        "Rolle" : "userAdminAnyDatabase",
                        "db" : "admin"
                },
                "readWriteAnyDatabase"
        ]
}
  • Starten Sie die mongod-Instanz neu
  • Greifen Sie erneut mit dem erstellten Benutzer und Passwort zu.
C:\Users\>mongo --port 27017 --authenticationDatabase "admin" -u "AdminUser" -p
MongoDB-Shell Version v4.2.7
Geben Sie das Passwort ein:
verbindung zu: mongodb://127.0.0.1:27017/?authSource=admin&compressors=disabled&gssapiServiceName=mongodb

45. Zugriffskontrollbenutzer abrufen und löschen

Mit dem folgenden Befehl können Sie die Benutzerinformationen überprüfen und löschen.

  • db.getBenutzer("AdminBenutzer")
  • db.dropBenutzer("AdminBenutzer")

Beispiel:

> db.getUser("AdminUser")
{
        "_id" : "admin.AdminUser",
        "userId" : UUID("78d2d5bb-0464-405e-b27e-643908a411ce"),
        "user" : "AdminUser",
        "db" : "admin",
        "roles" : [
                {
                        "role" : "userAdminAnyDatabase",
                        "db" : "admin"
                },
                {
                        "role" : "readWriteAnyDatabase",
                        "db" : "admin"
                }
        ],
        "Mechanismen" : [
                "SCRAM-SHA-1",
                "SCRAM-SHA-256"
        ]
}
> db.dropUser("AdminUser")
true
> db.getUser("AdminBenutzer")
null
>

46. Benutzerdefinierte Rollen gewähren

MongoDB stellt die Methode db.createRole() zur Verfügung, um die Privilegien für einen Benutzer und ein Array geerbter Rollen festzulegen.

  • Verbinden Sie die MongoDB-Instanz mit dem Benutzer admin.
  • Führen Sie den folgenden Befehl aus, um eine neue Rolle zu erzeugen.

Syntax:

db.createRole({role: "roleName",privileges:[{privilegeName}],roles:[InheritedArray]})

Beispiel:

admin verwenden
> db.createRole(
...    {
... Rolle: "abc",
... privileges: [ { resource: { db: "geekFlareDB", collection: "geekFlareCol" }, Aktionen: [ "killop" , "inprog"] } ],
... Rollen: []
...    }
... )
{
        "Rolle" : "abc",
        "privileges" : [
                {
                        "Ressource" : {
                                "db" : "geekFlareDB",
                                "Sammlung" : "geekFlareCol"
                        },
                        "actions" : [
                                "killop",
                                "inprog"
                        ]
                }
        ],
        "Rollen" : [ ]
}

47. Benutzerdefinierte Rollen widerrufen

Um die vorhandenen Rollen zu ändern, verwenden Sie den folgenden Befehl.

Syntax: db.revokeRolesFromUser( userName, [{ "role" : roleName , db:dbName} ] )

Beispiel:

> db.getUser("AdminUser")
{
        "_id" : "admin.AdminUser",
        "userId" : UUID("fe716ed1-6771-459e-be13-0df869c91ab3"),
        "user" : "AdminUser",
        "db" : "admin",
        "roles" : [
                {
                        "role" : "userAdminAnyDatabase",
                        "db" : "admin"
                },
                {
                        "role" : "readWriteAnyDatabase",
                        "db" : "admin"
                }
        ],
        "Mechanismen" : [
                "SCRAM-SHA-1",
                "SCRAM-SHA-256"
        ]
}
> db.revokeRolesFromUser( "AdminUser", [{ "role" : "userAdminAnyDatabase" , db: "admin"} ] )
> db.getUser("AdminUser")
{
        "_id" : "admin.AdminUser",
        "userId" : UUID("fe716ed1-6771-459e-be13-0df869c91ab3"),
        "user" : "AdminUser",
        "db" : "admin",
        "roles" : [
                {
                        "role" : "readWriteAnyDatabase",
                        "db" : "admin"
                }
        ],
        "Mechanismen" : [
                "SCRAM-SHA-1",
                "SCRAM-SHA-256"
        ]
}
>

48. MongoDB-Konnektivität mit Python

Das Paket pymongo wird benötigt, um MongoDB von der Python-Konsole aus zu verbinden.

>>> from pymongo import MongoClient
>>> mClient=MongoClient("mongodb://127.0.0.1:27017/")
>>> mDB=mClient.geekFlareDB
>>> mRecord={"_id":4,"name":"XYZ"}
>>> mDB.geekFlareCollection.insert_one(mRecord)
<pymongo.results.InsertOneResult Objekt bei 0x000002CC44256F48>
>>> for i in mDB.geekFlareCollection.find({"_id":4}):
... print(i)
...
{'_id': 4, 'Name': 'XYZ'}
>>>

Was kommt als Nächstes?

Sehen Sie sich diese Liste von NoSQL-Clients zur Verwaltung von MongoDB und anderen NoSQL-Datenbanken an. Wenn Sie beruflich häufig mit MongoDB zu tun haben, sollten Sie sich diesen Udemy-Kurs ansehen.