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_64Nous 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_642. 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 geekFlareDB5. 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.000GB6. 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
GeekFlare7. 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()
fauxOpé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éthode
find()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éthode
find({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éthodeupdateMany().
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
geekFlareColIndexation
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 enregistrements32. 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
Mongoavec l’optionreplsetsur 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=mongodb45. 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.