48 MongoDB-Befehle und -Abfragen, die Sie als Entwickler und DBA kennen sollten

Dieser Artikel befasst sich mit den häufig verwendeten Abfragen und Befehlen von MongoDB die von Entwicklern und DBA im täglichen Entwicklungs- und Betriebsleben verwendet werden.

Kurzes Intro

In dieser neuen Ära der intelligenten Technologie werden Daten in großem Umfang generiert, und jeder Teil der Daten ist für wachsende Branchen gleichermaßen wichtig. Die Benutzer erzeugen strukturierte, halbstrukturierte und unstrukturierte Daten in unbegrenzter 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 besteht die Notwendigkeit von NoSQL-Datenbank kommt ins Spiel.

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

Was ist MongoDB?

MongoDB ist eine dokumentenorientierte, plattformübergreifende und quelloffene NoSQL-Datenbank für die Speicherung halbstrukturierter Daten, die 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.

Fangen wir an.

Grundlegende Befehle

1. Versionskontrolle

Der erste Befehl dient dazu, die installierte Version des MongoDB-Servers und der Mongo Shell zu ü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
allocator: tcmalloc
modules: none
build environment:
    distmod: 2012plus
    distarch: x86_64
    target_arch: x86_64

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

mongo –version

C:\Windows\System32>mongo --version
MongoDB shell version v4.2.7
git version: 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
allocator: tcmalloc
modules: none
build environment:
    distmod: 2012plus
    distarch: x86_64
    target_arch: x86_64

2. Auflisten von MongoDB-Befehlen

Dieser Befehl hilft den Benutzern, alle Befehle herauszufinden, die in MongoDB verwendet werden können. Führen Sie den Befehl in der Mongo Shell aus.

help()

mongo> db.help()
DB methods:
        db.adminCommand(nameOrDocument) - switches to 'admin' db, and runs command [just calls db.runCommand(...)]
        db.aggregate([pipeline], {options}) - performs a collectionless aggregation on this database; returns a cursor
        db.auth(username, password)
        db.cloneDatabase(fromhost) - will only function with MongoDB 4.0 and below
        db.commandHelp(name) returns the help for the command
        db.copyDatabase(fromdb, todb, fromhost) - will only function with MongoDB 4.0 and below
        db.createCollection(name, {size: ..., capped: ..., max: ...})
        db.createUser(userDocument)
        db.createView(name, viewOn, [{$operator: {...}}, ...], {viewOptions})
        db.currentOp() displays currently executing operations in the db
        db.dropDatabase(writeConcern)
        db.dropUser(username)
        db.eval() - deprecated
        db.fsyncLock() flush data to disk and lock server for backups
        db.fsyncUnlock() unlocks server following a db.fsyncLock()
        db.getCollection(cname) same as db['cname'] or db.cname
        db.getCollectionInfos([filter]) - returns a list that contains the names and options of the db's collections
        db.getCollectionNames()
        db.getLastError() - just returns the err msg string
        db.getLastErrorObj() - return full status object
        db.getLogComponents()
        db.getMongo() get the server connection object
        db.getMongo().setSlaveOk() allow queries on a replication slave server
        db.getName()
        db.getProfilingLevel() - deprecated
        db.getProfilingStatus() - returns if profiling is on and slow threshold
        db.getReplicationInfo()
        db.getSiblingDB(name) get the db at the same server as this one
        db.getWriteConcern() - returns the write concern used for any operations on this db, inherited from server object if set
        db.hostInfo() get details about the server's host
        db.isMaster() check replica primary status
        db.killOp(opid) kills the current operation in the db
        db.listCommands() lists all the db commands
        db.loadServerScripts() loads all the scripts in db.system.js
        db.logout()
        db.printCollectionStats()
        db.printReplicationInfo()
        db.printShardingStatus()
        db.printSlaveReplicationInfo()
        db.resetError()
        db.runCommand(cmdObj) run a database command.  if cmdObj is a string, turns it into {cmdObj: 1}
        db.serverStatus()
        db.setLogLevel(level,<component>)
        db.setProfilingLevel(level,slowms) 0=off 1=slow 2=all
        db.setVerboseShell(flag) display extra information in shell output
        db.setWriteConcern(<write concern doc>) - sets the write concern for writes to the db
        db.shutdownServer()
        db.stats()
        db.unsetWriteConcern(<write concern doc>) - unsets the write concern for writes to the db
        db.version() current version of the server
        db.watch() - opens a change stream cursor for a database to report on all  changes to its non-system collections.

3. DB-Statistiken

Der unten stehende Befehl gibt Details zu den Datenbanken zusammen mit verschiedenen Sammlungen und zugehörigen Parametern dieser Datenbank an.

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, eine neue Datenbank zu erstellen, wenn sie nicht existiert, oder zu einer bestehenden Datenbank zu wechseln. In MongoDB ist "test" die Standarddatenbank, daher verwenden Benutzer "Test" DB, sobald Mongo Shell eingeloggt ist.

use DB_Name

mongos> use geekFlareDB
switched to db geekFlareDB

5. Auflistung aller Datenbanken

Der genannte Befehl wird verwendet, um alle Datenbanken aufzulisten.

show dbs

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

6. Prüfen Sie den aktuell verwendeten DB

Führen Sie den folgenden Befehl in der Mongo Shell aus, um die derzeit verwendete DB anzuzeigen.

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 Drop-Befehl ausführen. Andernfalls wird die Standarddatenbank "Test" Datenbank.

db.dropDatabase()

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

> show dbs
admin     0.000GB
config    0.001GB
local     0.000GB
test      0.000GB
training  0.000GB
>
> use training
switched to db training
>
> db.dropDatabase()
{ "dropped" : "training", "ok" : 1 }

8. Sammlung erstellen

Collections sind ähnlich wie 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 optionaler Parameter kann den Namen des Dokuments, seine Größe und den Index enthalten.

• Erstellen einer einfachen Sammlung.

Syntax: db.createCollection(Name,Options)

Beispiel:

> use geekFlare
switched to db geekFlare
>
> db.createCollection("geekFlareCollection")
{ "ok" : 1 }
>
> show collections
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 die Eigenschaft, die ältesten Dokumente zu entfernen, 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 wir 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. Tropfenabholung

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.

Bei erfolgreicher Übergabe wird true zurückgegeben, im Falle eines Fehlers oder wenn die DB nicht existiert, false.

Syntax: collectionName.drop()

Beispiel:

> use geekFlare
switched to db geekFlare
>
> show collections
geekFlareCollection
>
> db.geekFlareCollection.drop()
true
>
> db.geekFlareCollection.drop()
false

CRUD-Vorgänge bezogen

10. Dokument in Sammlung einfügen

In MongoDB entspricht ein Dokument einem Tupel in einem RDBMS.

Um ein Dokument zu erstellen, muss der insert() Methode verwendet wird. Die Methode insert() erstellt ein oder mehrere Dokumente in der bestehenden Sammlung. Sie erstellt auch eine Sammlung, wenn diese nicht in der DB vorhanden ist. In MongoDB ist das Dokument schema-los, d.h. es gibt keine Beschränkung beim Einfügen einer beliebigen Anzahl von Schlüsseln in ein Dokument.

• Einfügen eines einzelnen Datensatzes

So fügen Sie einen Datensatz ein insert() oder insertOne() Methode verwendet werden kann.

Syntax: collectionName.insertOne({document})

Beispiel:

> db.geekFlareCollection.insertOne( {
 code: "P123", Qty: 200, status: "Active"
});
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5ed309725429283aee2e134d")
}

• Einfügen mehrerer Datensätze

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

Syntax:

collectionName.insertMany([{document1},{document2},{ document3}….{ documentn}])

Beispiel:

db.geekFlareCollection.insertMany([
... { code: "P1", Qty: 100, status: "Active"},
... { code: "P2", Qty: 200, status: "Active"},
... { code: "P3", Qty: 0, status: "Dective"}
... ]);
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5edf7b4e18b2c26b9dfe8cac"),
                ObjectId("5edf7b4e18b2c26b9dfe8cad"),
                ObjectId("5edf7b4e18b2c26b9dfe8cae")
        ]
}
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75b8"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75b9"), "product" : "bread", "Qty" : 20 }
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75ba"), "product" : "yogurt", "Qty" : 30 }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cac"), "code" : "P1", "Qty" : 100, "status" : "Active" }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cad"), "code" : "P2", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cae"), "code" : "P3", "Qty" : 0, "status" : "Dective" }
>

• Datensatz in großen Mengen einfügen

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

Syntax:

var bulk = db.collectionName.initializeUnorderedBulkOp();

bulk.insert({document1} );

bulk.insert({document2} );

bulk.insert({documentn} );

bulk.execute();

Beispiel:

> var bulk = db.geekFlareCollection.initializeUnorderedBulkOp();
> bulk.insert({ code: "P1", Qty: 100, status: "Active"});
> bulk.insert({ code: "P2", Qty: 200, status: "Active"});
> bulk.insert({ code: "P3", Qty: 0, status: "Dective"});
> 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" : "Active" }
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8cb0"), "code" : "P2", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8cb1"), "code" : "P3", "Qty" : 0, "status" : "Dective" }
>

11. Dokument aus einer Sammlung abrufen

Für die Suche nach einem Dokument, das in einer Sammlung gespeichert ist, kann die find()-Methode verwendet werden. Der folgende Befehl wird verwendet, um alle Dokumente aus der Sammlung abzurufen.

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

Syntax: collectionName.find()

Beispiel:

> db.geekFlareCollection.find()
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86ce"), "code" : "P1", "Qty" : 200, "status" : "Active" }
{ "_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" : "Inactive" }

• find({condition}) Methode kann verwendet werden, um nur die erforderlichen Dokumente auf der Grundlage einiger Bedingungen aus der Sammlung abzurufen. MongoDB bietet eine Liste von Projektion und Abfrageoperatoren um den Wert des BSON-Typs abzurufen.

Syntax: collectionName.find({ condition })

Beispiel:

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

• Um nur ein Dokument abzurufen, bietet MongoDB die findOne()-Methode. Sie liefert eine formatierte Ausgabe.

Syntax: collectionName.findOne()

Beispiel:

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

12. Retrieval-Ausgabe verschönern

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

Syntax: collectionName.find().pretty()

Beispiel:

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

13. Dokument in einer Sammlung aktualisieren

MongoDB bietet update() Methode, um neue Werte für vorhandene Schlüssel in Dokumenten zu setzen. Der Aktualisierungsbefehl gibt Details über geänderte und übereinstimmende Dokumente an. Die Syntax des Update-Befehls lautet:

Syntax: collectionName.update({KeyToUpdate},{Set Command})

Beispiel:

> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "product" : "bread", "Qty" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "product" : "yogurt", "Qty" : 30 }
>
> db.geekFlareCollection.update({"product" : "bottles"},{$set : {"Qty": 10}}  )
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
>
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 10 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "product" : "bread", "Qty" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "product" : "yogurt", "Qty" : 30 }
>
>  db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 10 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "product" : "bread", "Qty" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "product" : "yogurt", "Qty" : 30 }

• updateOne() : Um ein einzelnes Dokument zu aktualisieren, gibt es updateOne() Methode. updateOne() gibt die Anzahl der übereinstimmenden und geänderten Dokumente an.

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 bestimmten Bedingungen zu aktualisieren, hat MongoDB updateMany() Methode.

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 das Dokument zu löschen, besteht MongoDB aus deleteOne() und deleteMany() Methoden. Die Syntax der Löschmethoden sind:

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

 Syntax: collectionName.deleteOne({DeletionCondition})

Beispiel:

> db.geekFlareCollection.deleteOne({"product" : "bread"})
{ "acknowledged" : true, "deletedCount" : 1 }

• <strong>deleteMany() </strong>entfernt alle Dokumente, die den Löschkriterien entsprechen. Ohne die Löschkriterien deleteMany({condition}) löscht alle Dokumente.

 Syntax: collectionName.deleteMany({DeletionCondition})

Beispiel:

> db.geekFlareCollection.deleteMany({"product" : "bottles"})
{ "acknowledged" : true, "deletedCount" : 2 }

• <strong>entfernen() </strong>Es gibt eine weitere Methode, um alle Dokumente zu löschen, die den Löschkriterien entsprechen. Die Methode remove() benötigt zwei Argumente, eines ist die Löschbedingung und das andere ist nur ein Flag.

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

Syntax: collectionName.remove({DeletionCondition},1)

Beispiel:

> db.geekFlareCollection.remove({"product" : "bottles"})
WriteResult({ "nRemoved" : 1 })

15. Unterscheidbarkeit abrufen

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

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

Syntax: collectionName.distinct(field)

Beispiel:

> db.geekFlareCollection.distinct("product")
[ "Cheese", "Snacks2", "Snacks3", "bread", "ketchup" ]

• Um eindeutige Datensätze aus einem Feld zu erhalten, während die Abfrage angegeben wird.

Syntax: collectionName.distinct(field,query)

Beispiel:

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

16. Sammlung umbenennen

MongoDB bietet renameCollection () Methode zum Umbenennen der Sammlung.

Syntax: collectionName.renameCollection(newCollectionName)

Beispiel:

>db.geekFlareCollection.renameCollection('geekFlareCol')
{ "ok" : 1 }
> show collections
geekFlareCol

Indizierung

17. Index auf Dokument erstellen

Indizes sind eine spezielle Datenstruktur, die einen kleinen Teil des Datensatzes der Sammlung in einer leicht zu durchsuchenden Form speichert. Indizes unterstützen die auf- und absteigende Reihenfolge der Feldwerte und ermöglichen so eine bessere Leistung beim Abruf.

MongoDB bietet die default_id Index. Außerdem unterstützt MongoDB die Erstellung von benutzerdefinierten Indizes. MongoDB-Indizes werden auf Sammlungsebene definiert und bieten Unterstützung für Felder oder Unterfelder eines Dokuments. Die Syntax für die Erstellung eines Indexes ist :

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

Syntax: collectionName.createIndex({Key: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({"product" : 1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}

• Erstellen Sie einen Index für mehrere Felder.

Syntax: collectionName.createIndex({Key1:1,key2:1…keyn:1})

Beispiel:

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

 18. Index auf Dokument anzeigen

MongoDB bietet getIndexes() Methode, 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

dropIndex() Methode wird verwendet, um einen einzelnen Index zu löschen, und die dropIndexes() Methode 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. Begrenzung des Abrufs von Dokumenten

limit() Methode hilft, die Anzahl der zurückgegebenen Dokumente zu begrenzen. Die Methode limit() nimmt numerische Argumente entgegen.

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

Beispiel:

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

21. Abrufen von Dokumenten überspringen

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

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

Beispiel:

> db.geekFlareCollection.find().skip(2)
{ "_id" : 3, "product" : "yogurt", "Qty" : 30 }
> db.geekFlareCollection.find().skip(3)

22. Sortieren und Abrufen von Dokumenten

MongoDB sort() Methode sortiert die Ausgabedokumente entweder in aufsteigender oder absteigender Reihenfolge. Diese Methode akzeptiert den Namen der Schlüssel mit der Nummer zur Angabe der Sortierreihenfolge. 1 wird für aufsteigende Reihenfolge verwendet, während -1 für absteigende Reihenfolge verwendet wird.

Syntax: collectionName.find().sort({key:1})

Beispiel:

> db.geekFlareCollection.find().sort({"Qty":1})
{ "_id" : 2, "product" : "bread", "Qty" : 20 }
{ "_id" : 3, "product" : "yogurt", "Qty" : 30 }
{ "_id" : 1, "product" : "bottles", "Qty" : 100 }

Validierung

23. Validierung von Dokumenten

Validatoren helfen dabei, die Art der Daten, die in die Dokumente eingefügt werden, einzuschränken. Validatoren werden in Sammlungen definiert. Für die Erstellung von Validatoren ist das Schlüsselwort Prüfer und optional Validierungsstufe und Validierungsmaßnahme um den Überprüfungsmodus festzulegen. Die Dokumentüberprüfung schränkt das Einfügen des neuen Feldes in das Dokument nicht ein.

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

Beispiel:

> db.createCollection( "Login",
...  { validator: { $and:
...       [
...          { phone: { $type: "string" } },
...          { email: { $regex: /@flares\.com$/ } },
...          { status: { $in: [ "Registered", "Unknown" ] } }
...       ]
...    }
... } )
{ "ok" : 1 }
>
> db.Login.insert({phone:1234})
WriteResult({
        "nInserted" : 0,
        "writeError" : {
                "code" : 121,
                "errmsg" : "Document failed validation"
        }
})
>
> db.Login.insert({phone:"1234",email:"abc@flares.com",status:"Unknown",mode:"limited"})
WriteResult({ "nInserted" : 1 })

24. Schemavalidatoren für eine neue Sammlung

Zusätzliches Schlüsselwort $jsonSchema zusammen mit zusätzliche Eigenschaften Wert als Falsch ist erforderlich, um Einschränkungen auf der Schemaebene vorzunehmen. Sie 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",
...             pattern : "@flares\.com$",
...             description: "string meets the given expression"
...          },
...          status: {
...             enum: [ "registered", "Invalid" ],
...             description: "status must be within enum values"
...          }
...       }
...    } },
... } )
{ "ok" : 1 }
>
> db.Login.insert({email:"abc@flares.com"})
WriteResult({
        "nInserted" : 0,
        "writeError" : {
                "code" : 121,
                "errmsg" : "Document failed validation"
        }
})

25. Schemavalidatoren für eine bestehende Sammlung aktualisieren oder erstellen

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

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",
            pattern : "@flares\.com$",
            description: "string meets the given expression"
         },
         status: {
            enum: [ "registered", "Invalid" ],
            description: "status must be within enum values"
         }
      }
   } },
      validationAction: "error",
         validationLevel: "strict"
} )
{ "ok" : 1 }

26. Schemavalidatoren für eine bestehende Sammlung entfernen

Um Schemavalidatoren zu entfernen, müssen Sie die <strong>validationLevel</strong> wie aus.

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

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

Syntax: getCollectionInfos({name : “collectionName”})

Beispiel:

> db.getCollectionInfos({name: "Login"})
[
        {
                "name" : "Login",
                "type" : "collection",
                "options" : {
                        "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 verwandt

28. Cursor in MongoDB

Der Cursor ist ein Zeiger zur Iteration über die Ergebnismenge. MongoDB verwendet <strong>hasNext()</strong> und <strong>forEach()</strong> Methode für die Iteration. Eine Liste von Cursor-Methoden zur Verfügung gestellt wurde.

Beispiele:

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

Dienstprogramm

29. Erstellen einer Datenbanksicherung

mongodump 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. Es erzeugt eine binäre Sicherung zusammen mit Metadateninformationen.

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    writing geekFlareDB.myTable to
2020-06-02T12:26:34.430+0530    writing geekFlareDB.geekFlareCollection to
2020-06-02T12:26:34.430+0530    writing geekFlareDB.mCollection to
2020-06-02T12:26:34.433+0530    writing geekFlareDB.users to
2020-06-02T12:26:34.434+0530    done dumping geekFlareDB.myTable (2 documents)
2020-06-02T12:26:34.434+0530    done dumping geekFlareDB.geekFlareCollection (4 documents)
2020-06-02T12:26:34.435+0530    writing geekFlareDB.contacts2 to
2020-06-02T12:26:34.435+0530    writing geekFlareDB.Login to
2020-06-02T12:26:34.436+0530    done dumping geekFlareDB.mCollection (2 documents)
2020-06-02T12:26:34.437+0530    done dumping geekFlareDB.users (1 document)
2020-06-02T12:26:34.437+0530    done dumping geekFlareDB.Login (0 documents)
2020-06-02T12:26:34.438+0530    done dumping geekFlareDB.contacts2 (0 documents)

30. Wiederherstellung der Datenbank aus der Sicherung

Der Nutzen <strong>mongorestore</strong> wird verwendet, um binäre Daten wiederherzustellen, die von mongodump.

Syntax: mongorestore --db newDB "pathOfOldBackup"

Beispiel:

C:\Users\asad.ali>mongorestore  --db geekFlareNew  "C:\mongodb\dump\geekFlare" --host "127.0.0.1:27017"
2020-06-09T15:49:35.147+0530    the --db and --collection args should only be used when restoring from a BSON file. Other uses are deprecated and will not exist in the future; use --nsInclude instead
2020-06-09T15:49:35.148+0530    building a list of collections to restore from C:\mongodb\dump\geekFlare dir
2020-06-09T15:49:35.152+0530    reading metadata for geekFlareNew.geekFlareCollection from C:\mongodb\dump\geekFlare\geekFlareCollection.metadata.json
2020-06-09T15:49:35.321+0530    restoring geekFlareNew.geekFlareCollection from C:\mongodb\dump\geekFlare\geekFlareCollection.bson
2020-06-09T15:49:35.461+0530    no indexes to restore
2020-06-09T15:49:35.462+0530    finished restoring geekFlareNew.geekFlareCollection (3 documents, 0 failures)
2020-06-09T15:49:35.467+0530    3 document(s) restored successfully. 0 document(s) failed to restore.

31. Sammlungen exportieren

So exportieren Sie den Inhalt der Sammlung in eine Datei (JSON oder CSV) mongoexport zur Verfügung gestellt. Verwenden Sie zur Ausführung dieses Befehls das Systemterminal.

• Exportieren Sie eine einzelne Sammlung in eine Datei.

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

Beispiel:

C:\mongodb\New folder>mongoexport --db geekFlareDB --collection geekFlareCol --out outFile.json
2020-06-06T19:02:29.994+0530    connected to: mongodb://localhost/
2020-06-06T19:02:30.004+0530    exported 6 records

• Exportieren Sie ein bestimmtes Feld aus der Sammlung in eine Datei.

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

Beispiel:

C:\mongodb\New folder>mongoexport --db geekFlareDB --collection geekFlareCol --out outFile.json --fields product
2020-06-06T19:05:22.994+0530    connected to: mongodb://localhost/
2020-06-06T19:05:23.004+0530    exported 6 records

32. Sammlungen importieren

So importieren Sie Daten aus einer Datei (CSV oder JSON) mongoimport Befehlszeilentool verwendet werden kann.

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    connected to: mongodb://localhost/
2020-06-09T14:52:53.924+0530    6 document(s) imported successfully. 0 document(s) failed to import.

Replik bezogen

Replikation ist etwas anderes als Sharding, sehen Sie sich diesen Leitfaden an Sharding implementieren.

33. MongoDB-Replikation

Die Replikation ist ein Prozess zur Synchronisierung von Daten auf mehreren Servern. Sie verhindert Datenverluste aufgrund von Hardware- oder Softwarefehlfunktionen. 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 Schreibvorgänge und der sekundäre Datensatz liest vom primären. Für einen Mongo-Replikatsatz sind mindestens 3 Datensätze erforderlich. Der folgende Prozess ist erforderlich, um ein Replikatset einzurichten:

• Start mongod Server mit replset Option 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, host: "IP:27019" }    ] })

> rs.initiate( {
...    _id : "rs0",
...    members: [
...   { _id: 0, host: "localhost:27017" },
...   { _id: 1, host: "localhost:27018" },
...   { _id: 2, host: "localhost:27019" }
...    ]
... })
{
        "ok" : 1,
        "$clusterTime" : {
                "clusterTime" : Timestamp(1591089166, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        },
        "operationTime" : Timestamp(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 den Replikationssatz 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),
                        "votes" : 1
                },
                {
                        "_id" : 1,
                        "host" : "localhost:27018",
                        "arbiterOnly" : false,
                        "buildIndexes" : true,
                        "hidden" : false,
                        "priority" : 1,
                        "tags" : {

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

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

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

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

 35. Hinzufügen einer neuen MongoDB-Instanz zu einer Replikatgruppe

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

Syntax: rs.add(“hostname:port”)

Beispiel:

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

36. Vorhandene MongoDB-Instanz aus dem Replikatsatz entfernen

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

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

Beispiel:

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

 37. Primäres als sekundäres Replikatset erstellen

MongoDB bietet einen Befehl, um das primäre Replikat anzuweisen, ein sekundäres Replikatset zu werden.

Syntax: rs.stepDown( stepDownSecs , secondaryCatchupSecs )

Beispiel:

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

38. Prüfen Sie den Replikationsrückstand zwischen Primär und Sekundär

Der folgende Befehl wird verwendet, um den Replikationsrückstand zwischen allen Replikatsätzen des Primärsystems zu überprüfen.

Syntax: rs.printSlaveReplicationInfo()

Beispiel:

rs0:PRIMARY> rs.printSlaveReplicationInfo()
source: localhost:27018
        syncedTo: Tue Jun 02 2020 16:14:04 GMT+0530 (India Standard Time)
        0 secs (0 hrs) behind the primary
source: localhost:27019
        syncedTo: Thu Jan 01 1970 05:30:00 GMT+0530 (India Standard Time)
        1591094644 secs (441970.73 hrs) behind the primary
source: localhost:27016
        syncedTo: Tue Jun 02 2020 16:14:04 GMT+0530 (India Standard Time)
        0 secs (0 hrs) behind the primary
rs0:PRIMARY>

Transaktionen im Zusammenhang mit

39. Transaktionen in MongoDB

MongoDB unterstützt ACID-Eigenschaften für Transaktionen mit 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 Replikatsätzen oder Mangos unterstützt. Sobald die Sitzung erfolgreich übertragen wurde, sind die innerhalb der Sitzung durchgeführten Vorgänge auch außerhalb der Sitzung sichtbar.

• Sitzung beginnen

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

• Transaktion starten,

Syntax: session.startTransaction()

• Transaktion abschließen

Syntax: session.commitTransaction()

Beispiel:

Wir erstellen eine Sitzung, starten die Transaktion, führen eine Einfügung/Aktualisierung durch und übertragen die Transaktion.

rs0:PRIMARY> session = db.getMongo().startSession()
session { "id" : UUID("f255a40d-81bd-49e7-b96c-9f1083cb4a29") }
rs0:PRIMARY> session.startTransaction()
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.insert([
... {_id: 4 , product: "ketchup"},
... {_id: 5, product: "Cheese"}
... ]);
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 2,
        "nUpserted" : 0,
        "nMatched" : 0,
        "nModified" : 0,
        "nRemoved" : 0,
        "upserted" : [ ]
})
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
{ "_id" : 4, "product" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }
rs0:PRIMARY> db.geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
rs0:PRIMARY> session.commitTransaction()
rs0:PRIMARY> db.geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
{ "_id" : 4, "product" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
{ "_id" : 4, "product" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }

40. Einzelbeleg-Transaktionen Konflikt

Wenn zwei Transaktionen versuchen, dasselbe Dokument zu aktualisieren, löst MongoDB einen Schreibkonfliktfehler 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" : Timestamp(1591174593, 1),
        "ok" : 0,
        "errmsg" : "WriteConflict",
        "code" : 112,
        "codeName" : "WriteConflict",
        "$clusterTime" : {
                "clusterTime" : Timestamp(1591174593, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
})
rs0:PRIMARY>

41. Mehrbeleg-Transaktionen

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

• db.getMongo().startTransaction()

Einfügen/Aktualisieren von mehreren Dokumenten

• Sitzung.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, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "Snacks2", "Qty" : 100 }
{ "_id" : 3, "product" : "Snacks3", "Qty" : 20 }
{ "_id" : 4, "product" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }
rs0:PRIMARY>

42. Profilerstellung in MongoDB

Profiling hilft bei der Protokollierung langsamer Abfragen in der system.profile Sammlung. Profiler-Ebene und Stichprobenrate definieren den Prozentsatz der zu protokollierenden Abfragen system.profile Sammlung.

• Profilierungsebene festlegen/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

Syntaxdb.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  [main] Automatically disabling TLS 1.0, to force-enable TLS 1.0 specify --sslDisabledProtocols 'none'
2020-06-09T02:34:41.113-0700 W  ASIO     [main] No TransportLayer configured during NetworkInterface startup
2020-06-09T02:34:41.113-0700 I  CONTROL  [initandlisten] MongoDB starting : pid=22604 port=27017 dbpath=C:\data\data1 64-bit host=MCGL-4499
2020-06-09T02:34:41.114-0700 I  CONTROL  [initandlisten] targetMinOS: Windows 7/Windows Server 2008 R2
2020-06-09T02:34:41.116-0700 I  CONTROL  [initandlisten] db version v4.2.7
2020-06-09T02:34:41.116-0700 I  CONTROL  [initandlisten] git version: 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212 

43. MongoDB Erklären()

MongoDB explains() Methode liefert Statistiken und Informationen, um einen erfolgreichen Plan auszuwählen und ihn bis zum Ende auszuführen. Sie gibt die Ergebnisse gemäß der Ausführlichkeitsplan.

Syntax: collectionName.explain(“verbosityName”)

Um die Methode/den Befehl explain() auszuführen, erstellen wir eine Ausführlichkeit und dann die Methode explain() ausführen. Sehen Sie sich das folgende Beispiel an, in dem diese Schritte ausgeführt wurden.

Beispiel:

> db.runCommand(
...    {
...       explain: { count: "product", query: { Qty: { $gt: 10 } } },
...       verbosity: "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( { product: "bread"} )
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "geekFlareDB.geekFlareCol",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "product" : {
                                "$eq" : "bread"
                        }
                },
                "winningPlan" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "product" : {
                                        "$eq" : "bread"
                                }
                        },
                        "direction" : "forward"
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 2,
                "executionTimeMillis" : 0,
                "totalKeysExamined" : 0,
                "totalDocsExamined" : 6,
                "executionStages" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "product" : {
                                        "$eq" : "bread"
                                }
                        },
                        "nReturned" : 2,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 8,
                        "advanced" : 2,
                        "needTime" : 5,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "direction" : "forward",
                        "docsExamined" : 6
                }
        },
        "serverInfo" : {
                "host" : "MCGL-4499",
                "port" : 27017,
                "version" : "4.2.7",
                "gitVersion" : "51d9fe12b5d19720e72dcd7db0f2f17dd9a19212"
        },
        "ok" : 1
}
>

Zugangskontrolle

44. Zugriffskontrolle in MongoDB

Zugriffskontrollfunktionen ermöglichen den Authentifizierungszugriff auf vorhandene Benutzer. Für die Zugriffskontrolle aktiviert DB, um sicherzustellen, dass ein Benutzer Admin-Rolle in admin DB erstellen.

• DB ohne Authentifizierung verbinden.
• Wechsel zur Datenbank

use admin

• Benutzer wie unten erstellen

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

 Beispiel:

db.createUser(
...   {
...     user: "AdminUser",
...     pwd: passwordPrompt(),
...     roles: [ { role: "userAdminAnyDatabase", db: "admin" }, "readWriteAnyDatabase" ]
...   }
... )
Enter password:
Successfully added user: {
        "user" : "AdminUser",
        "roles" : [
                {
                        "role" : "userAdminAnyDatabase",
                        "db" : "admin"
                },
                "readWriteAnyDatabase"
        ]
}

• Neustart mongod Instanz
• 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
Enter password:
connecting to: 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 Benutzerdaten überprüfen und löschen.

• db.getUser("AdminUser")
• db.dropUser("AdminUser")

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"
                }
        ],
        "mechanisms" : [
                "SCRAM-SHA-1",
                "SCRAM-SHA-256"
        ]
}
> db.dropUser("AdminUser")
true
> db.getUser("AdminUser")
null
>

46. Benutzerdefinierte Rollen zuweisen

MongoDB bietet db.createRole() Methode, um die Privilegien für einen Benutzer und ein Array von geerbten Rollen anzugeben.

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

Syntax:

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

Beispiel:

use admin
> db.createRole(
...    {
...      role: "abc",
...      privileges: [ { resource: { db: "geekFlareDB", collection: "geekFlareCol" }, actions: [ "killop" ,"inprog"] } ],
...      roles: []
...    }
... )
{
        "role" : "abc",
        "privileges" : [
                {
                        "resource" : {
                                "db" : "geekFlareDB",
                                "collection" : "geekFlareCol"
                        },
                        "actions" : [
                                "killop",
                                "inprog"
                        ]
                }
        ],
        "roles" : [ ]
}

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"
                }
        ],
        "mechanisms" : [
                "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"
                }
        ],
        "mechanisms" : [
                "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 object at 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-Kunden um MongoDB und andere NoSQL-Datenbanken zu verwalten. Wenn Sie beruflich häufig mit MongoDB zu tun haben, dann sollten Sie mehr über dieses Thema erfahren Udemy-Kurs.