48 Commandes et requêtes MongoDB à connaître en tant que développeur et DBA

Cet article décrit les requêtes et commandes fréquemment utilisées de MongoDB utilisé par les développeurs et les administrateurs de bases de données dans leur vie quotidienne de développement et d'exploitation.

Introduction rapide

Dans cette nouvelle ère de technologie intelligente, les données sont généréesated en grand volume et chaque élément de données est équivalentally important pour growindustries du secteur. Les utilisateurs génèrent des données structurées, semi-structurées et non structurées en quantité illimitée. Composition de données structuréesrises stocker les données dans des tableaux et rows tandis que les données non structurées sont constituées d'images, de vidéos et de clips vocaux. En raison de l'augmentation du volume de données structurées et non structurées, la nécessité de Base de données NoSQL vient dans l'image.

Il offre aux développeurs une facilité de conception de schéma et une évolutivité platformulaire aux administrateurs de bases de données, il fournit un accès sécurisé et rapide platformulaire.

Qu'est-ce que MongoDB?

MongoDB est un outil cross-orienté orienté vers les documents.platformulaire et base de données NoSQL open source utilisée pour stocker des données semi-structurées écrites en C++. Au lieu de tableaux et rows, MongoDB stocke les données dans des paires clé-valeur. Pour rendre l'apprentissage facile et sans tracas pour les développeurs et les administrateurs, voici quelques-unes des commandes MongoDB fréquemment utilisées.

Commençons.

Commandes de base

1. Vérification de la version

La commande principale consiste à vérifier la version installée du serveur MongoDB et de Mongo Shell. Exécutez cette commande sur le terminal sous Linux ou à l'invite CMD sur windows.

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

Nous pouvons aussi utiliser mongod pour vérifier la version, comme suit.

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. Liste des commandes MongoDB

Cette commande aidera les utilisateurs à découvrir toutes les commandes qui peuvent être utilisées dans MongoDB. Exécutez la commande sur Mongo Shell.

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. Statistiques DB

La commande ci-dessous donnera des détails sur les bases de données ainsi que plusieurs collections et related paramètres de cette base de données.

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. Créate Nouvelle base de données ou basculer vers une base de données existante

Cette commande simple aide à créerate une nouvelle base de données si elle n'existe pas ou aide à passer à la base de données existante. Dans MongoDB, « test » est la base de données par défaut, les utilisateurs utilisent donc «tester”DB une fois que Mongo Shell est connecté.

use DB_Name

mongos> use geekFlareDB
switched to db geekFlareDB

5. Liste de toutes les bases de données

La commande mentionnée est utilisée pour lister toutes les bases de données.

show dbs

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

6. Vérifiez la base de données actuellement utilisée

Exécutez la commande ci-dessous sur Mongo Shell pour voir la base de données actuellement utilisée.

db

> db
GeekFlare

 7. Supprimer la base de données

La commande donnée aide l'utilisateur à supprimer la base de données requise. Exécutez la commande sur le client MongoDB. Assurez-vous de sélectionner la base de données avant d'exécuter la commande drop. Autrewise, il supprimera la valeur par défaut "tester" Base de données.

db.dropDatabase()

Commençons par lister toutes les bases de données, basculons vers l'une d'entre elles, puis déposons-la

> 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. Créate Collection

Les collections sont similaires aux tables du SGBDR.

Create une commande de collection se compose de deux paramètres. La collection se compose de zero ou plusieurs documents. Par conséquent, pour créer une collection, le paramètre obligatoire à utiliser dans la commande est son nom et paramètre facultatif peut inclure le nom des documents, sa taille et son index.

• Créer une collection simple.

Syntaxe: db.createCollection(Name,Options)

Exemple:

> use geekFlare
switched to db geekFlare
>
> db.createCollection("geekFlareCollection")
{ "ok" : 1 }
>
> show collections
geekFlareCollection

• Créer une collection limitée

Dans ce cas, limitez la taille et le nombre de documents à insérer dans la collection. La collection plafonnée a une propriété pour supprimer les documents les plus anciens pour faire de la place pour les nouveaux documents.

Syntaxe:

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

Mise en situation : Créonsate une collection plafonnée, insérer un enregistrement et le récupérer

> 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. Collecte des gouttes

La commande Drop Collection est similaire au DDL dans le SGBDR. Il acquiert des verrous sur la collection requise jusqu'à l'exécution de la commande. Drop collection supprime la collection de la base de données ainsi que tous les index associésated avec cette collection. Pour supprimer la collection, la méthode drop() est requise.

Il renvoie true pour une suppression réussie et false en cas d'erreur ou si la base de données n'existe pas.

Syntaxe: collectionName.drop()

Exemple:

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

Opérations CRUD related

10. Insérer le document dans la collection

Dans MongoDB, le document est similaire à un tuple dans le SGBDR.

Pour créerate un document, le insert() méthode est utilisée. La méthode insert() créeates un ou plusieurs documents de la collection existante. Cela crée égalementates si elle n'est pas présente dans la base de données. Dans MongoDB, Document est sans schéma, cela signifie qu'il n'y a aucune restriction quant à l'insertion d'un nombre quelconque de clés dans un document.

• Insérer un seul enregistrement

Pour insérer un enregistrement insert() or insertOne() méthode peut être utilisée.

Syntaxe: collectionName.insertOne({document})

Exemple:

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

• Insertion de plusieurs enregistrements

Pour insérer de nombreux enregistrements, une liste d'enregistrements sera transmise à insert() or insertMany() méthode.

Syntaxe:

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

Exemple:

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" }
>

• Insérer un enregistrement en masse

Un grand nombre de documents peuvent également être insérés de manière ordonnée et non ordonnée en exécutant initializeOrderedBulkOp() et le initializeUnorderedBulkOp() méthodes.

Syntaxe:

var bulk = db.collectionName.initializeUnorderedBulkOp();

bulk.insert({document1} );

bulk.insert({document2} );

bulk.insert({documentn} );

bulk.execute();

Mise en situation :

> 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. Récupérer le document d'une collection

Pour rechercher le document stocké dans une collection, la méthode find () peut être utilisée. La commande ci-dessous sera utilisée pour récupérer tous les documents de la collection.

• find()peut être utilisée pour récupérer tous les documents stockés dans une collection.

Syntaxe: collectionName.find()

Exemple:

> 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}) peut être utilisée pour récupérer uniquement les documents requis en fonction de certaines conditions de la collection. MongoDB fournit une liste de opérateurs de projection et de requête pour récupérer la valeur de type BSON.

Syntaxe: collectionName.find({ condition })

Exemple:

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

• Pour récupérer un seul document, MongoDB fournit le findOne() méthode. Il donne une sortie formatée.

Syntaxe: collectionName.findOne()

Exemple:

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

12. Embellissez la sortie de récupération

La find() méthode donne une sortie désorganisée. MongoDB fournit pretty() commandes pour obtenir la sortie formatée.

Syntaxe: collectionName.find().pretty()

Exemple:

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

13. Mise à jourate Document dans une collection

MongoDB fournit update() méthode pour définir de nouvelles valeurs pour les clés existantes dans les documents. Mise à jourate La commande donne des détails sur les documents modifiés et correspondants. Syntaxe de mise à jourate la commande est:

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

Exemple:

> 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() : Pour mettre à jourate un seul document existe updateOne() méthode. updateOne() donnez le nombre de documents appariés et modifiés.

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

Exemple:

> db.geekFlareCollection.updateOne({"product" : "bottles"},{$set : {"Qty": 40}}  )
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

• <strong>updateMany()</strong> : Pour mettre à jourate plusieurs documents sous certaines conditions que MongoDB a updateMany() méthode.

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

Exemple:

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

14. Supprimer le document d'une collection

Pour supprimer le document, MongoDB se compose de deleteOne() et le deleteMany() méthodes. La syntaxe des méthodes de suppression est:

• <strong>deleteOne({condition}) </strong>supprime le document unique répondant aux critères de suppression.

 Syntaxe: collectionName.deleteOne({DeletionCondition})

Exemple:

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

• <strong>deleteMany() </strong>supprime tous les documents correspondant aux critères de suppression. Sans les critères de suppression deleteMany({condition}) supprime tous les documents.

 syntaxe: collectionName.deleteMany({DeletionCondition})

Exemple:

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

• <strong>remove() </strong>Il existe une autre méthode pour supprimer tous les documents correspondant aux critères de suppression. remove () prend deux arguments, l'un est la condition de suppression et l'autre n'est qu'un indicateur.

        Notes: La méthode Remove est obsolèteated dans les versions à venir.

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

Exemple:

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

15. Récupérer Distinct

La distinct() méthode est utilisée pour obtenir des enregistrements uniques.

• Pour obtenir des enregistrements distincts à partir d'un champ.

Syntaxe: collectionName.distinct(field)

Exemple:

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

• Pour obtenir des enregistrements distincts à partir d'un champ tout en spécifiant la requête.

Syntaxe: collectionName.distinct(field,query)

Exemple:

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

16. Renommer la collection

MongoDB fournit renameCollection () méthode pour renommer la collection.

Syntaxe: collectionName.renameCollection(newCollectionName)

Exemple:

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

Indexage

17. Créate Index sur le document

Les index sont une structure de données spéciale qui stocke une petite partie de l'ensemble de données de la collection sous une forme facile à parcourir. Les index prennent en charge l'ordre croissant et décroissant des valeurs des champs et facilitent ainsiate meilleures performances lors de la récupération.

MongoDB fournit le default_id indice. De plus, MongoDB prend en charge le creation d’index définis par l’utilisateur. Les index MongoDB sont définis au niveau des collections et fournissent des supports au niveau du champ ou du sous-champ d'un document. Syntaxe de create l'indice est :

• Create un index sur un seul champ.

Syntaxe: collectionName.createIndex({Key:1})

En cela, l'indicateur cléates le champ sur lequel l'index est crééated et 1 signifient l’ordre croissant. Pour créerate un index par ordre décroissant -1 peut être utilisé.

Exemple:

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

• Create un index sur plusieurs champs.

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

Exemple:

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

 18. Afficher l'index sur le document

MongoDB fournit getIndexes() méthode pour lister tous les index créésated sur un document.

Syntaxe: collectionName.getIndexes()

Exemple:

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

19. Supprimer l'index du document

dropIndex() est utilisée pour supprimer l'index unique et la méthode dropIndexes () est utilisée pour supprimer plusieurs index.

• Supprimer un index unique

Syntaxe: collectionName.dropIndex({key})

Exemple:

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

• Supprimer plusieurs index.

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

Exemple:

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

Récupération related

20. Limiter la récupération des documents

limit() permet de limiter le nombre de documents renvoyés. La méthode limit () accepte les arguments numériques.

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

Exemple:

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

21. Ignorer la récupération des documents

MongoDB prend en charge skip() méthode. Cette méthode ignore le nombre requis de documents. Il accepte un argument numérique.

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

Exemple:

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

22. Trier la récupération des documents

MongoDB sort() méthode trie les documents de sortie par ordre croissant ou décroissant. Cette méthode accepte le nom des clés avec le nombre pour spécifier l'ordre de tri 1 est utilisé pour l'ordre croissant tandis que -1 est utilisé pour spécifier l'ordre décroissant.

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

Exemple:

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

Validation related

23. Validation des documents

Les validateurs aident à restreindre le type de données insérées dans les documents. Les validateurs sont définis lors de la collecte. Validateur creation est requis pour utiliser le mot-clé validateur et facultatif niveau de validation et le action de validation pour spécifier le mode de validation. La validation du document ne limite pas l'insertion du nouveau champ dans le document.

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

Mise en situation :

> 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. Validateurs de schéma sur une nouvelle collection

Mot clé supplémentaire $ jsonSchema avec propriétés supplémentaires valeur comme Faux est nécessaire pour mettre une restriction au niveau du schéma. C'est prevents nouveaux champs à ajouter dans le document.

Syntaxe: createCollection(“collectionName”,{validator: { $jsonSchema { schema condition } }})

Exemple:

> 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. Mise à jourate ou Create Validateurs de schéma sur une collection existante

Un validateur peut être crééated sur la collection existante en utilisant collMod

Syntaxe: runCommand({collMod:”collectionName”,validator:{schema condition}})

Mise en situation :  

> 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. Supprimer les validateurs de schéma sur une collection existante

Pour supprimer les validateurs de schéma, il faut définir <strong>validationLevel</strong> comme off.

Syntaxe: runCommand({collMod:”collectionName”,validator:{ },validationLevel:off})

Exemple:

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

27. Rechercher des validateurs sur une collection existante

Pour vérifier si la collection existante a des validateurs de schéma exécutés ci-dessous la commande. Sans spécifier le nom de la collection db.getCollectionInfos() La méthode donne des détails sur les validateurs sur toutes les collections résidant dans une base de données.

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

Exemple:

> 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"
                }
        }
]

Curseurs related

28. Curseur dans MongoDB

Le curseur est un pointeur vers iterate sur l’ensemble de résultats. MongoDB utilise <strong>hasNext()</strong> et le <strong>forEach()</strong> méthode d'itération. Une liste de méthodes de curseur a été fourni.

Exemples:

> 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 

utilitaire

29. Sauvegarde de la base de données

mongodump L'utilitaire est utilisé pour exporter le contenu de la base de données MongoDB en tant que sauvegarde. Cette commande s'exécute depuis la console système et non depuis le shell mongo. Cela généreraate sauvegarde binaire avec informations de métadonnées.

Syntaxe:

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

 Mise en situation :

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. Restauration de la base de données à partir de la sauvegarde

l'utilitaire <strong>mongorestore</strong> est utilisé pour restaurer le générateur de données binairesated par mongodump.

Syntaxe: mongorestore --db newDB "pathOfOldBackup"

Exemple:

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. Exportation de collections

Pour exporter le contenu de la collection vers un fichier (JSON ou CSV) mongoexport l'utilité a été fournie. Pour exécuter cette commande, utilisez le terminal système.

• Exportez une seule collection vers un fichier.

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

Exemple:

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

• Exportez un champ spécifique de la collection vers un fichier.

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

Exemple:

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. Importation de collections

Pour importer des données depuis un fichier (CSV ou JSON) mongoimport l'outil de ligne de commande peut être utilisé.

Syntaxe: 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.

Réplique related

La réplication est différente du sharding, consultez ce guide pour implémenter le partage.

33. Réplication MongoDB

La réplication est la process à syncSynchronisez les données sur plusieurs serveurs. C'est prevperte de données suite à un dysfonctionnement du matériel ou du logiciel. MongoDB réalise la réplication à l'aide d'ensembles de réplicas. Le jeu de réplicas se compose d'ensembles de données Mongo primaires et secondaires dans le cluster.

L’ensemble de données primaire accepte toutes les opérations d’écriture et les lectures d’ensembles de données secondaires à partir du primaire. Au moins 3 ensembles de données sont requis dans l'ensemble Mongo Replica. Ci-dessous process est requis pour configurer un jeu de réplicas :

• Accueil mongod serveur avec replset option sur un minimum de 3 nœuds.

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

• Initialisez le jeu de réplicas.

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. Vérifier l'état de la réplication

Exécutez la commande ci-dessous à partir du nœud de réplica principal pour obtenir des informations complètes sur l'ensemble de répliques.

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. Ajouter une nouvelle instance MongoDB à un jeu de réplicas

Démarrez le client MongoDB principal et exécutez la commande ci-dessous

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

Exemple:

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. Supprimer l'instance MongoDB existante du jeu de réplicas

La commande ci-dessous supprimera l'hôte secondaire requis du jeu de réplicas.

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

Exemple:

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. Faire du primaire comme jeu de réplicas secondaire

MongoDB fournit une commande pour demander au réplica principal de devenir un jeu de réplicas secondaire.

Syntaxe: rs.stepDown( stepDownSecs , secondaryCatchupSecs )

Exemple:

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. Vérifiez le décalage de réplique entre le primaire et le secondaire

La commande ci-dessous sera utilisée pour vérifier le décalage de réplication entre tous les jeux de réplicas du primaire.

Syntaxe: rs.printSlaveReplicationInfo()

Exemple:

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>

Transactions related

39. Transactions dans MongoDB

MongoDB prend en charge les propriétés ACID pour les transactions sur les documents.

Pour démarrer une transaction, une session est requise pour démarrer et une validation est requise pour enregistrer les modifications dans la base de données. Les transactions sont prises en charge sur les jeux de répliques ou les mangues. Une fois la session validée, les opérations effectuées à l'intérieur de la session seront visibles à l'extérieur.

• Démarrer la session

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

• Commencer la transaction,

Syntaxe: session.startTransaction()

• Valider la transaction

Syntaxe: session.commitTransaction()

Exemple:

Créonsate une session, démarrer la transaction, effectuer quelques insertions/mises à jourate puis validez la transaction.

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. Conflit de transactions sur un seul document

Si deux transactions ont tenté de mettre à jourate le même document, MongoDB erows erreur de conflit d'écriture.

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

Effectuer quelques insertions/mises à jourate sur Session1 suivi de sur Session2. Observez maintenant l'erreur dans l'exemple ci-dessous

Exemple:

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. Transactions multi-documents

MongoDB prend en charge les transactions multi-documents en une seule session.

• db.getMongo ().startTransaction ()

Effectuer quelques insertions/mises à jourate sur plusieurs documents

• session.commitTransaction ()

Exemple:

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. Profiling dans MongoDB

Profiling aide à enregistrer les requêtes lentes dans le system.profile collecte. Profiniveau supérieur et échantillon rate définir le pourcentage de requêtes à connecter system.profile collecte.

• Définir/Obtenir Profiniveau de linge

Syntaxe:

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

• Gagnez Profistatut ling

Syntaxe: db.getProfilingStatus()

> db.getProfilingStatus()
{ "was" : 2, "slowms" : 1, "sampleRate" : 1 }

• Autoriser profiling au niveau de l'instance MongoDB, démarrez l'instance avec profiler informations ou ajouter profiles détails du fichier de configuration.

Syntaxe:

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

Exemple:

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 Explain ()

MongoDB explains() La méthode renvoie des statistiques et fournit des informations pour sélectionner un plan gagnant et l'exécuter jusqu'à son terme. Il renvoie les résultats selon le plan de verbosité.

Syntaxe: collectionName.explain(“verbosityName”)

Pour exécuter la méthode/commande expliquer(), créonsate a verbosité puis exécutez la méthode explic (), jetez un œil à l'exemple ci-dessous, où ces étapes ont été exécutées.

Exemple:

> 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
}
>

Contrôle d'accès related

44. Contrôle d'accès dans MongoDB

Les fonctionnalités de contrôle d'accès permettent l'authentification de l'accès aux utilisateurs existants. Pour que le contrôle d'accès soit activé, la base de données garantit la créationate un rôle d'administrateur utilisateur dans la base de données admin.

• Connectez DB sans authentification.
• Passer à la base de données

use admin

• Create utilisateur comme ci-dessous

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

 Mise en situation :

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"
        ]
}

• Recommencer mongod instance
• Accédez à nouveau avec created utilisateur et mot de passe.

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. Récupérer et supprimer l'utilisateur du contrôle d'accès

La commande ci-dessous peut être utilisée pour vérifier les informations de l'utilisateur et les supprimer.

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

Exemple:

> 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. ​​Attribuer des rôles définis par l'utilisateur

MongoDB fournit db.createRole() pour spécifier les privilèges d'un utilisateur et un tableau de rôles hérités.

• Connectez l'instance MongoDB à l'utilisateur admin.
• Exécutez la commande ci-dessous pour générerate un nouveau rôle.

Syntaxe:

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

Exemple:

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. Revoke Rôles définis par l'utilisateur

Pour modifier les rôles existants, utilisez la commande ci-dessous.

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

Exemple:

> 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. Connectivité MongoDB avec Python

Le package pymongo est requis pour connecter MongoDB à partir de la console python.

>>> 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'}
>>>

Quelle est la prochaine?

Consultez cette liste de Clients NoSQL pour gérer MongoDB et d'autres bases de données NoSQL. Si votre travail implique de travailler fréquemment sur MongoDB, vous voudrez peut-être en savoir plus Cours Udemy.