Cet article présente les requêtes et les commandes de MongoDB fréquemment utilisées par les développeurs et les administrateurs de bases de données dans le cadre de leurs activités quotidiennes de développement et d’exploitation.

Intro rapide

Dans cette nouvelle ère de technologie intelligente, les données sont générées en grand volume et chaque élément de données est tout aussi important pour les industries en croissance. Les utilisateurs génèrent des données structurées, semi-structurées et non structurées en quantité illimitée. Les données structurées comprennent le stockage des données dans des tableaux et des lignes, tandis que les données non structurées sont des images, des vidéos et des clips vocaux. En raison de l’augmentation du volume de données structurées et non structurées, la nécessité d’une base de données NoSQL s’impose.

Elle permet aux développeurs de concevoir facilement des schémas et aux administrateurs de bases de données de disposer d’une plateforme évolutive, sécurisée et rapide.

Qu’est-ce que MongoDB ?

MongoDB est une base de données NoSQL orientée documents, multiplateforme et open-source, utilisée pour stocker des données semi-structurées écrites en C . Au lieu de tableaux et de lignes, MongoDB stocke les données sous forme de paires clé-valeur. Pour faciliter l’apprentissage des développeurs et des administrateurs, voici quelques-unes des commandes MongoDB les plus fréquemment utilisées.

Commençons par le commencement.

Commandes de base

1. Vérification de la version

La commande la plus importante permet de vérifier la version installée du serveur MongoDB et de Mongo Shell. Exécutez cette commande dans le terminal sous Linux ou dans l’invite CMD sous Windows.

mongod --version

C:\NWindows\NSystem32>mongod --version
version de la base de données : v4.2.7
version git : 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
allocateur : tcmalloc
modules : aucun
environnement de construction :
    distmod : 2012plus
    distarch : x86_64
    target_arch : x86_64

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

mongo -version

C:\NWindows\NSystem32>mongo --version
MongoDB shell version v4.2.7
version git : 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
allocateur : tcmalloc
modules : aucun
environnement de construction :
    distmod : 2012plus
    distarch : x86_64
    architecture_cible : x86_64

2. Liste des commandes MongoDB

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

help()

mongo> db.help()
Méthodes de la base de données :
        db.adminCommand(nameOrDocument) - bascule dans la base de données "admin" et exécute la commande [appelle simplement db.runCommand(...)]
        db.aggregate([pipeline], {options}) - effectue une agrégation sans collection sur cette base de données ; renvoie un curseur
        db.auth(nom d'utilisateur, mot de passe)
        db.cloneDatabase(fromhost) - ne fonctionne qu'avec MongoDB 4.0 et moins
        db.commandHelp(name) renvoie l'aide de la commande
        db.copyDatabase(fromdb, todb, fromhost) - ne fonctionne qu'avec MongoDB 4.0 et moins
        db.createCollection(name, {size : ..., capped : ..., max : ...})
        db.createUser(userDocument)
        db.createView(name, viewOn, [{$operator : {...}}, ...], {viewOptions})
        db.currentOp() affiche les opérations en cours d'exécution dans la base de données
        db.dropDatabase(writeConcern)
        db.dropUser(nomd'utilisateur)
        db.eval() - obsolète
        db.fsyncLock() envoie les données sur le disque et verrouille le serveur pour les sauvegardes
        db.fsyncUnlock() déverrouille le serveur après un db.fsyncLock()
        db.getCollection(cname) identique à db['cname'] ou db.cname
        db.getCollectionInfos([filter]) - renvoie une liste contenant les noms et les options des collections de la base de données
        db.getCollectionNames()
        db.getLastError() - renvoie la chaîne de caractères du message d'erreur
        db.getLastErrorObj() - renvoie l'objet d'état complet
        db.getLogComponents()
        db.getMongo() récupère l'objet de connexion au serveur
        db.getMongo().setSlaveOk() autorise les requêtes sur un serveur esclave de réplication
        db.getName()
        db.getProfilingLevel() - obsolète
        db.getProfilingStatus() - renvoie si le profilage est activé et si le seuil de lenteur est atteint
        db.getReplicationInfo()
        db.getSiblingDB(name) récupère la base de données sur le même serveur que celle-ci
        db.getWriteConcern() - renvoie le souci d'écriture utilisé pour toutes les opérations sur cette base de données, hérité de l'objet serveur s'il est défini
        db.hostInfo() obtient des détails sur l'hôte du serveur
        db.isMaster() vérifie le statut primaire du réplica
        db.killOp(opid) tue l'opération en cours dans la base de données
        db.listCommands() liste toutes les commandes de la base de données
        db.loadServerScripts() charge tous les scripts dans db.system.js
        db.logout()
        db.printCollectionStats()
        db.printReplicationInfo()
        db.printShardingStatus()
        db.printSlaveReplicationInfo()
        db.resetError()
        db.runCommand(cmdObj) exécute une commande de base de données. si cmdObj est une chaîne, elle est transformée en {cmdObj : 1}
        db.serverStatus()
        db.setLogLevel(level,<component>)
        db.setProfilingLevel(level,slowms) 0=off 1=slow 2=all
        db.setVerboseShell(flag) affiche des informations supplémentaires dans la sortie de l'interpréteur de commandes
        db.setWriteConcern(<préoccupation d'écriture doc>) - définit la préoccupation d'écriture pour les écritures dans la base de données
        db.shutdownServer()
        db.stats()
        db.unsetWriteConcern(<préoccupation d'écriture doc>) - désactive la préoccupation d'écriture pour les écritures dans la base de données
        db.version() version actuelle du serveur
        db.watch() - ouvre un curseur de flux de changement pour une base de données afin de signaler toutes les modifications apportées à ses collections hors système.

3. Statistiques de la base de données

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

db.stats()

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

4. Créez une nouvelle base de données ou passez à une base de données existante

Cette commande simple permet de créer une nouvelle base de données si elle n’existe pas ou de basculer vers la base de données existante. Dans MongoDB, “test” est la base de données par défaut et les utilisateurs utilisent donc la base de données “test” une fois que Mongo Shell est connecté.

use DB_Name

mongos> use geekFlareDB
basculé vers la base de données 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 en cours d’utilisation

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

db

> db
GeekFlare

7. Abandonner la base de données

La commande donnée permet à l’utilisateur de supprimer la base de données requise. Exécutez la commande sur le client MongoDB. Veillez à sélectionner la base de données avant d’exécuter la commande Drop. Dans le cas contraire, la base de données par défaut “test” sera supprimée.

db.dropDatabase()

Commençons par lister toutes les bases de données, basculons sur l’une d’entre elles et abandonnons-la

> show dbs
admin 0.000GB
config 0.001GB
local 0.000GB
test 0.000GB
training 0.000GB
>
> utiliser l'entraînement
basculé sur l'entraînement de la base de données
>
> db.dropDatabase()
{ "dropped" : "training", "ok" : 1 }

8. Créer une collection

Les collections sont similaires aux tables dans les SGBDR.

La commande de création d’une collection se compose de deux paramètres. La collection se compose de zéro document ou plus. Ainsi, pour créer une collection, le paramètre obligatoire à utiliser dans la commande est son nom et les paramètres facultatifs peuvent inclure le nom des documents, leur taille et leur index.

  • Création d’une collection simple.

Syntaxe: db.createCollection(Name,Options)

Exemple: > use geekFlare

> utiliser geekFlare
basculé vers db geekFlare
>
> db.createCollection("geekFlareCollection")
{ "ok" : 1 }
>
> afficher les collections
geekFlareCollection
  • Création d’une collection plafonnée

Dans cette collection, vous limitez la taille et le nombre des documents à insérer dans la collection. La collection plafonnée possède une propriété qui permet de supprimer les documents les plus anciens pour faire de la place aux nouveaux documents.

Syntaxe:

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

Exemple : Créons une collection plafonnée, insérons un enregistrement et récupérons-le

> 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" : vrai,
        "insertedIds" : [
                ObjectId("5edc5f4f411247725e75e52e"),
                ObjectId("5edc5f4f411247725e75e52f"),
                ObjectId("5edc5f4f411247725e75e530")
        ]
}
>
> db.Login.find()
{ "_id" : ObjectId("5edc5f4f411247725e75e530"), "id" : 3, "status" : "Pending" }

9. Drop Collection

La commande Drop Collection est similaire à DDL dans un SGBDR. Elle acquiert des verrous sur la collection requise jusqu’à l’exécution de la commande. La commande Drop Collection supprime la collection de la base de données ainsi que tous les index associés à cette collection. La méthode drop() est nécessaire pour supprimer la collection.

Elle renvoie un message vrai si l’abandon est réussi et un message faux en cas d’erreur ou si la base de données n’existe pas.

Syntaxe: collectionName.drop()

Exemple:

> utiliser geekFlare
basculé vers db geekFlare
>
> afficher les collections
geekFlareCollection
>
> db.geekFlareCollection.drop()
vrai
>
> db.geekFlareCollection.drop()
faux

Opérations CRUD

10. Insérer un document dans une collection

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

Pour créer un document, la méthode insert() est utilisée. La méthode insert() crée un ou plusieurs documents dans la collection existante. Elle crée également une collection si elle n’est pas présente dans la base de données. Dans MongoDB, le document est sans schéma, ce qui signifie qu’il n’y a aucune restriction quant à l’insertion d’un nombre quelconque de clés dans un document.

  • Insertion d’un seul enregistrement

Pour insérer un enregistrement, vous pouvez utiliser la méthode insert() ou insertOne().

Syntaxe: collectionName.insertOne({document})

Exemple:

> db.geekFlareCollection.insertOne( {
 code : "P123", Qty : 200, status : "Active"
}) ;
{
        "acknowledged" : vrai,
        "insertedId" : ObjectId("5ed309725429283aee2e134d")
}
  • Insertion de plusieurs enregistrements

Pour insérer plusieurs enregistrements, une liste d’enregistrements sera transmise à la méthode insert() ou insertMany().

Syntaxe:

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

Exemple:

db.geekFlareCollection.insertMany([
... { code : "P1", Qty : 100, statut : "Active"},
... { code : "P2", Qté : 200, statut : "Actif"},
... { code : "P3", Qté : 0, statut : "Déctif"}
... ]) ;
{
        "acknowledged" : vrai,
        "insertedIds" : [
                ObjectId("5edf7b4e18b2c26b9dfe8cac"),
                ObjectId("5edf7b4e18b2c26b9dfe8cad"),
                ObjectId("5edf7b4e18b2c26b9dfe8cae")
        ]
}
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75b8"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75b9"), "produit" : "pain", "Qté" : 20 }
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75ba"), "produit" : "yaourt", "Qté" : 30 }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cac"), "code" : "P1", "Qté" : 100, "status" : "Active" }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cad"), "code" : "P2", "Qté" : 200, "statut" : "Actif" }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cae"), "code" : "P3", "Qté" : 0, "status" : "Dective" }
>
  • Insertion d’un enregistrement en masse

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

Syntaxe: var bulk = db.collectionNom

var bulk = db.collectionName.initializeUnorderedBulkOp() ;

bulk.insert({document1} ) ;

bulk.insert({document2} ) ;

bulk.insert({documentn} ) ;

bulk.execute() ;

Exemple :

> 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", "Qté" : 200, "statut" : "Actif" }
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8cb1"), "code" : "P3", "Qté" : 0, "status" : "Dective" }
>

11. Récupérer un document dans une collection

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

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

Syntaxe: collectionNom.find()

Exemple: > db.geekFlareCollection.find()

> db.geekFlareCollection.find()
{"_id" : ObjectId("5ed31186b6f2c2bb1edb86ce"), "code" : "P1", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86cf"), "code" : "P2", "Qté" : 200, "statut" : "Actif" }
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86d0"), "code" : "P3", "Qté" : 200, "statut" : "Actif" }
{ "_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"), "code" : "P4", "Qté" : 100, "status" : "Inactive" }
  • la méthodefind({condition}) peut être utilisée pour extraire de la collection uniquement les documents requis en fonction de certaines conditions. MongoDB fournit une liste d’opérateurs de projection et de requête pour récupérer des valeurs de type BSON.

Syntaxe: collectionName.find({ condition })

Exemple:

> db.geekFlareCollection.find({ Qty : { $eq : 100 }}) ;
{ "_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"), "code" : "P4", "Qté" : 100, "status" : "Inactive" }
  • Pour récupérer un seul document, MongoDB propose la méthode findOne(). Elle fournit une sortie formatée.

Syntaxe: collectionName.findOne()

Exemple: > db.geekFlareCollection.findOne()

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

12. Sortie de l’extraction de l’embellissement

La méthode find() produit un résultat désorganisé. MongoDB fournit des commandes pretty() pour obtenir une sortie formatée.

Syntaxe: collectionName.find().pretty()

Exemple:

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

13. Mise à jour d’un document dans une collection

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

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

Exemple:

> db.geekFlareCollection.find()
{"_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "produit" : "pain", "Qté" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "produit" : "yaourt", "Qté" : 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"), "produit" : "pain", "Qté" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "produit" : "yaourt", "Qté" : 30 }
>
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "produit" : "bouteilles", "Qté" : 10 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "produit" : "pain", "Qté" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "produit" : "yaourt", "Qté" : 30 }
  • updateOne(): Pour mettre à jour un seul document, il existe la méthode updateOne (). updateOne() donne le nombre de documents correspondants 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 à jour plusieurs documents selon certaines conditions, MongoDB dispose de la méthode updateMany().

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

Exemple:

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

14. Supprimer un document d’une collection

Pour supprimer un document, MongoDB propose les méthodes deleteOne() et deleteMany(). La syntaxe des méthodes de suppression est la suivante :

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

Syntaxe: collectionName.deleteOne({Condition de suppression})

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({Condition de suppression})

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. La méthode remove() prend deux arguments, l’un étant la condition de suppression et l’autre un simple drapeau.

Remarque: la méthode Remove est obsolète dans les versions à venir.

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

Exemple:

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

15. Récupérer des éléments distincts

La méthode distinct() 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("produit")
[ "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", "pain" ]

16. Renommer la collection

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

Syntaxe: collectionName.renameCollection(newCollectionName)

Exemple:

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

Indexation

17. Créer un index sur le document

Les index sont une structure de données spéciale qui stocke une petite partie de l’ensemble des données de la collection sous une forme facile à parcourir. Les index permettent de classer les valeurs des champs par ordre croissant ou décroissant, ce qui améliore les performances lors de la recherche.

MongoDB fournit l’index default_id. MongoDB prend également en charge la création d’index définis par l’utilisateur. Les index MongoDB sont définis au niveau des collections et prennent en charge les champs ou sous-champs d’un document. La syntaxe de création d’un index est la suivante : :

  • Créez un index sur un seul champ.

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

La clé indique le champ sur lequel l’index est créé et 1 signifie l’ordre croissant. Pour créer un index dans l’ordre décroissant, vous pouvez utiliser -1.

Exemple:

> db.geekFlareCollection.createIndex({"product" : 1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
  • Créez 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 propose la méthode getIndexes() pour répertorier tous les index créés sur un document.

Syntaxe: collectionName.getIndexes()

Exemple: > db.geekFlareCollection.getIndexes()

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

19. Supprimer l’index du document

la méthodedropIndex() est utilisée pour supprimer un seul index et la méthode dropIndexes() est utilisée pour supprimer plusieurs index.

  • Suppression d’un seul index

Syntaxe: collectionName.dropIndex({key})

Exemple:

> db.geekFlareCollection.dropIndex({"product" : 1})
{ "nIndexesWas" : 3, "ok" : 1 }
  • Suppression d’index multiples.

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

Exemple:

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

Récupération liée

20. Limiter la recherche de documents

la méthode limit( ) permet de limiter le nombre de documents retournés. La méthode limit() accepte des arguments numériques.

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

Exemple: > db.geekFlareCollection.find().limit(number)

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

21. Sauter l’extraction des documents

MongoDB prend en charge la méthode skip(). Cette méthode permet d’ignorer le nombre requis de documents. Elle accepte un argument numérique.

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

Exemple: > db.geekFlareCollection.find().skip(number)

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

22. Récupération triée des documents

La méthode MongoDB sort () permet de trier les documents de sortie dans l’ordre croissant ou décroissant. Cette méthode accepte le nom des clés et 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 liée

23. Validation des documents

Les validateurs permettent de limiter le type de données insérées dans les documents. Les validateurs sont définis sur la collection. Pour créer un validateur, il faut utiliser le mot-clé validator et, en option, le niveau de validation et l’action de validation pour spécifier le mode de validation. La validation de document ne limite pas l’insertion d’un nouveau champ dans le document.

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

Exemple :

> 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" : "La validation du document a échoué"
        }
})
>
> 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

Le mot-clé supplémentaire $jsonSchema ainsi que la valeur False des propriétés supplémentaires sont nécessaires pour imposer une restriction au niveau du schéma. Cela empêche l’ajout de nouveaux champs dans le document.

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

Exemple:

> db.createCollection("Login", {
... validator : { $jsonSchema : {
... bsonType : "object",
...        "additionalProperties" : false,
... required : ["email" ],
... propriétés : {
... email : {
... bsonType : "string",
... pattern : "@flares\c.com$",
... description : "string meets the given expression"
...          },
... statut : {
... enum : [ "registered", "Invalid" ],
... description : "Le statut doit être compris dans les valeurs de l'enum"
...          }
...       }
...    } },
... } )
{ "ok" : 1 }
>
> db.Login.insert({email : "abc@flares.com"})
WriteResult({
        "nInserted" : 0,
        "writeError" : {
                "code" : 121,
                "errmsg" : "La validation du document a échoué"
        }
})

25. Mettre à jour ou créer des validateurs de schéma sur une collection existante

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

Syntaxe: runCommand({collMod : "nomCollection",validateur:{conditionSchéma}})

Exemple : 

> db.runCommand( {
collMod : "Login",
   validator : { $jsonSchema : {
       bsonType : "object",
 "additionalProperties" : false,
      required : ["email", "status" ],
      properties : {
         email : {
            bsonType : "string",
            pattern : "@flares\c.com$",
            description : "string meets the given expression"
         },
         status : {
            enum : [ "registered", "Invalid" ],
            description : "le statut doit être compris dans les valeurs de l'énumération"
         }
      }
   } },
      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 est nécessaire de désactiver le <strong>niveau de validation (validationLevel</strong> ).

Syntaxe: runCommand({collMod : "nomcollection",validator:{ },validationLevel:off})

Exemple:

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

27. Vérifier la présence de validateurs sur une collection existante

Pour vérifier si la collection existante possède des validateurs de schéma, exécutez la commande suivante. Sans spécifier le nom de la collection, la méthode db.getCollectionInfos() donne des détails sur les validateurs de toutes les collections résidant dans une base de données.

Syntaxe: getCollectionInfos({nom : "nomcollection"})

Exemple:

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

Curseurs liés

28. Curseur dans MongoDB

Le curseur est un pointeur qui permet d’itérer sur l’ensemble des résultats. MongoDB utilise les méthodes <strong>hasNext()</strong> et <strong>forEach()</strong> pour l’itération. Une liste des méthodes de curseur a été fournie.

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

Utilité

29. Sauvegarde d’une base de données

l’utilitairemongodump est utilisé pour exporter le contenu de la base de données MongoDB en tant que sauvegarde. Cette commande s’exécute à partir de la console système et non à partir du shell MongoDB. Elle génère une sauvegarde binaire accompagnée d’informations sur les métadonnées.

Syntaxe de la commande :

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

Exemple :

C:\Nmongodb\dump>mongodump --db geekFlareDB --out "C:\Nmongodb\dump" --host "127.0.0.1:27017"
2020-06-02T12:26:34.428 0530 écriture de geekFlareDB.myTable dans
2020-06-02T12:26:34.430 0530 écriture de geekFlareDB.geekFlareCollection vers
2020-06-02T12:26:34.430 0530 écriture de geekFlareDB.mCollection vers
2020-06-02T12:26:34.433 0530 écriture de geekFlareDB.users vers
2020-06-02T12:26:34.434 0530 dumping de geekFlareDB.myTable terminé (2 documents)
2020-06-02T12:26:34.434 0530 done dumping geekFlareDB.geekFlareCollection (4 documents)
2020-06-02T12:26:34.435 0530 écriture de geekFlareDB.contacts2 dans
2020-06-02T12:26:34.435 0530 écriture de geekFlareDB.login à
2020-06-02T12:26:34.436 0530 dumping de geekFlareDB.mCollection terminé (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 les données binaires générées par mongodump.

Syntaxe: mongorestore --db newDB "pathOfOldBackup"

Exemple:

C:\Users\asad.ali>mongorestore --db geekFlareNew "C:\Nmongodb\dump\geekFlare" --host "127.0.0.1:27017"
2020-06-09T15:49:35.147 0530 Les arguments --db et --collection ne doivent être utilisés que lors de la restauration à partir d'un fichier BSON. Les autres utilisations sont dépréciées et n'existeront plus dans le futur ; utilisez --nsInclude à la place
2020-06-09T15:49:35.148 0530 construction d'une liste de collections à restaurer à partir du répertoire C:\Nmongodb\Ndump\NgeekFlare
2020-06-09T15:49:35.152 0530 lecture des métadonnées pour geekFlareNew.geekFlareCollection depuis C:\mongodb\dump\geekFlare\geekFlareCollection.metadata.json
2020-06-09T15:49:35.321 0530 Restauration de geekFlareNew.geekFlareCollection à partir de C:\Nmongodb\dump\NgeekFlare\NgeekFlareCollection.bson
2020-06-09T15:49:35.461 0530 aucun index à restaurer
2020-06-09T15:49:35.462 0530 restauration terminée de geekFlareNew.geekFlareCollection (3 documents, 0 échecs)
2020-06-09T15:49:35.467 0530 3 document(s) restauré(s) avec succès. 0 document(s) n'a pas été restauré.

31. Exportation des collections

Pour exporter le contenu d’une collection vers un fichier (JSON ou CSV), l’utilitaire Mongoexport a été fourni. 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:\NMongodb\NNNouveau dossier>mongoexport --db geekFlareDB --collection geekFlareCol --out outFile.json
2020-06-06T19:02:29.994 0530 connecté à : mongodb://localhost/
2020-06-06T19:02:30.004 0530 exporté 6 enregistrements
  • Exportez un champ spécifique de la collection vers un fichier.

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

Exemple:

C:\NMongodb\NNNouveau dossier>mongoexport --db geekFlareDB --collection geekFlareCol --out outFile.json --fields product
2020-06-06T19:05:22.994 0530 connecté à : mongodb://localhost/
2020-06-06T19:05:23.004 0530 a exporté 6 enregistrements

32. Importation de collections

Pour importer des données à partir d’un fichier (CSV ou JSON), vous pouvez utiliser l’outil de ligne de commande mongoimport.

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 connecté à : mongodb://localhost/
2020-06-09T14:52:53.924 0530 6 document(s) importé(s) avec succès. 0 document(s) n'a pas été importé.

Relatif à la réplique

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

33. Réplication MongoDB

La réplication est le processus de synchronisation des données sur plusieurs serveurs. Elle permet d’éviter les pertes de données dues à des dysfonctionnements matériels ou logiciels. MongoDB réalise la réplication à l’aide d’ensembles de répliques. L’ensemble de répliques 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 l’ensemble de données secondaire lit les données de l’ensemble primaire. Un minimum de 3 ensembles de données est requis dans l’ensemble de répliques Mongo. Le processus suivant est nécessaire pour configurer un ensemble de répliques :

  • Démarrez le serveur Mongo avec l’option replset 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 l’ensemble de répliques.

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

> rs.initiate( {
...    _id : "rs0",
... membres : [
...   { _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, "AAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        },
        "operationTime" : Timestamp(1591089166, 1)
}

34. Vérifiez l’état de la réplication

Exécutez la commande ci-dessous à partir du nœud de réplique primaire 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" : faux,
                        "priority" : 1,
                        "tags" : {

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

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

                        },
                        "slaveDelay" : NumberLong(0),
                        "votes" : 1
                },
                {
                        "_id" : 3,
                        "host" : "localhost:27016",
                        "arbiterOnly" : faux,
                        "buildIndexes" : true,
                        "hidden" : faux,
                        "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 ensemble de répliques

Démarrez le client MongoDB primaire et exécutez la commande suivante

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

Exemple: rs0:PRIMAIRE> rs.add(“nom d’hôte:port”)

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

36. Supprimez l’instance MongoDB existante de l’ensemble de répliques

La commande ci-dessous supprimera l’hôte secondaire requis de l’ensemble 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, "AAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        },
        "operationTime" : Timestamp(1591095681, 1)
}
rs0:PRIMARY>

37. Faire de l’ensemble de réplicas primaire un ensemble de réplicas secondaire

MongoDB fournit une commande pour demander à un réplica primaire de devenir un ensemble de répliques secondaire.

Syntaxe: rs.stepDown( stepDownSecs , secondaryCatchupSecs )

Exemple:

rs0:PRIMARY> rs.stepDown(12)
{
        "ok" : 1,
        "$clusterTime" : {
                "clusterTime" : Timestamp(1591096055, 1),
                "signature" : {
                        "hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
                        "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élai de réplication entre tous les ensembles de répliques 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 sec (0 hrs) derrière le primaire
source : localhost:27019
        syncedTo : Thu Jan 01 1970 05:30:00 GMT 0530 (India Standard Time)
        1591094644 secs (441970.73 hrs) derrière la source primaire
source : localhost:27016
        syncedTo : Tue Jun 02 2020 16:14:04 GMT 0530 (India Standard Time)
        0 sec (0 hrs) derrière le primaire
rs0:PRIMARY>

Transactions liées

39. Transactions dans MongoDB

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

Pour lancer une transaction, une session est nécessaire pour démarrer, et la validation est nécessaire pour enregistrer les modifications dans la base de données. Les transactions sont prises en charge sur les ensembles de répliques ou les mangos. Une fois que la session a été validée avec succès, les opérations effectuées à l’intérieur de la session seront visibles à l’extérieur.

  • Démarrer une session

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

  • Démarrer la transaction,

Syntaxe: session.startTransaction()

  • Validation de la transaction

Syntaxe: session.commitTransaction()

Exemple:

Créons une session, démarrons la transaction, effectuons quelques insertions/mises à jour puis validons 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, produit : "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, "produit" : "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:PRIMAIRE> db.geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
{ "_id" : 4, "produit" : "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, "produit" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }

40. Document unique Transactions Conflit

Si deux transactions tentent de mettre à jour le même document, MongoDB génère une erreur de conflit d’écriture.

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

Effectuez des insertions/mises à jour sur Session1 puis sur Session2. Observez maintenant l’erreur dans l’exemple ci-dessous

Exemple:

rs0:PRIMARY> session1.startTransaction()
rs0:PRIMAIRE> session2.startTransaction()
rs0:PRIMAIRE> 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, "AAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
})
rs0:PRIMARY>

41. Transactions multi-documents

MongoDB supporte les transactions multi-documents dans une même session.

  • db.getMongo().startTransaction()

Effectuer des insertions/mises à jour sur plusieurs documents

  • session.commitTransaction()

Exemple:

rs0:PRIMARY> var session = db.getMongo().startSession()
rs0:PRIMAIRE> session.startTransaction()
rs0:PRIMAIRE> 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:PRIMAIRE> 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. Profilage dans MongoDB

Le profilage permet d’enregistrer les requêtes lentes dans la collection system.profile. Le niveau de profilage et le taux d’échantillonnage définissent le pourcentage de requêtes à enregistrer dans la collection system.profile.

  • Définir/obtenir le niveau de profilage

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
  • Obtenir l’état du profilage

Syntaxe: db.getProfilingStatus()

> db.getProfilingStatus()
{ "was" : 2, "slowms" : 1, "sampleRate" : 1 }
  • Pour activer le profilage au niveau de l’instance MongoDB, démarrez l’instance avec des informations de profilage ou ajoutez des détails de profilage dans le fichier de configuration.

Syntaxe:

mongod --profile <Niveau> --slowms <heure> --slowOpSampleRate <%Logging>

Exemple:

C:\NWindows\NSystem32>mongod --port 27017 --dbpath C:\Ndata\Ndata1 --profil 1 --slowms 25 --slowOpSampleRate 0.5
2020-06-09T02:34:41.110-0700 I CONTROL [ <x>main]</x> Désactivation automatique de TLS 1.0, pour forcer l'activation de TLS 1.0, spécifiez --sslDisabledProtocols 'none'
2020-06-09T02:34:41.113-0700 W ASIO [ <x>main]</x> No TransportLayer configured during NetworkInterface startup
2020-06-09T02:34:41.113-0700 I CONTROL [ <x><x><x>initandlisten]</x></x></x> MongoDB démarre : pid=22604 port=27017 dbpath=C:\data\data1 64-bit host=MCGL-4499
2020-06-09T02:34:41.114-0700 I CONTROL [ <x><x><x>initandlisten]</x></x></x> targetMinOS : Windows 7/Windows Server 2008 R2
2020-06-09T02:34:41.116-0700 I CONTROL [ <x><x><x>initandlisten]</x></x></x> db version v4.2.7
2020-06-09T02:34:41.116-0700 I CONTROLE [ <x><x><x>initandlisten]</x></x></x> git version : 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212

43. MongoDB Explain()

La méthode MongoDB explains() renvoie des statistiques et fournit des informations permettant de sélectionner un plan gagnant et de l’exécuter jusqu’au bout. Elle renvoie les résultats en fonction du plan de verbosité.

Syntaxe: collectionName.explain("verbosityName")

Pour exécuter la méthode/commande explain(), créons une verbosité puis exécutons la méthode explain(). Regardez l’exemple ci-dessous, dans lequel ces étapes ont été exécutées.

Regardez l’exemple ci-dessous, dans lequel ces étapes ont été exécutées :

> 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, "executionTimeMillisEstimate" : 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" : "pain"
                                }
                        },
                        "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

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

Les fonctions de contrôle d’accès permettent d’authentifier l’accès aux utilisateurs existants. Pour que le contrôle d’accès soit activé dans la base de données, vous devez créer un rôle d’administrateur pour l’utilisateur dans la base de données d’administration.

  • Connectez-vous à la base de données sans authentification.
  • Accédez à la base de données

utilisez admin

  • Créez un utilisateur comme ci-dessous

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

Exemple :

db.createUser(
...   {
... utilisateur : "AdminUser",
... pwd : passwordPrompt(),
... roles : [ { role : "userAdminAnyDatabase", db : "admin" }, "readWriteAnyDatabase" ]
...   }
... )
Entrez le mot de passe :
L'utilisateur a été ajouté avec succès : {
        "user" : "AdminUser",
        "roles" : [
                {
                        "role" : "userAdminAnyDatabase",
                        "db" : "admin"
                },
                "readWriteAnyDatabase"
        ]
}
  • Redémarrez l’instance de mongod
  • Accédez à nouveau avec l’utilisateur et le mot de passe créés.
C:\NUsers\>mongo --port 27017 --authenticationDatabase "admin" -u "AdminUser" -p
MongoDB shell version v4.2.7
Entrez votre mot de passe :
connexion à : 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 le supprimer.

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

Exemple: > db.getUser(“AdminUser”)

> 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. Octroi de rôles définis par l’utilisateur

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

  • Connectez l’instance MongoDB avec l’utilisateur admin.
  • Exécutez la commande ci-dessous pour créer un nouveau rôle.

Syntaxe:

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

Exemple:

utilisez admin
> db.createRole(
...    {
... rôle : "abc",
... privilèges : [ { resource : { db : "geekFlareDB", collection : "geekFlareCol" }, actions : [ "killop" , "inprog"] } } ],
... rôles : []
...    }
... )
{
        "role" : "abc",
        "privileges" : [
                {
                        "resource" : {
                                "db" : "geekFlareDB",
                                "collection" : "geekFlareCol"
                        },
                        "actions" : [
                                "killop",
                                "inprog"
                        ]
                }
        ],
        "roles" : [ ]
}

47. Révoquer les rôles définis par l’utilisateur

Pour modifier les rôles existants, utilisez la commande suivante.

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 paquet pymongo est nécessaire pour se 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'}
>>>

Que se passe-t-il ensuite ?

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 en suivant ce cours Udemy.