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

Cet article décrit les requêtes et commandes fréquemment utilisées de MongoDB utilisé par les développeurs et les administrateurs de bases de données dans leur vie quotidienne de développement et d'exploitation.
Introduction rapide
Dans cette nouvelle ère de technologie intelligente, les données sont généréesated en grand volume et chaque élément de données est équivalentally important pour growindustries du secteur. Les utilisateurs génèrent des données structurées, semi-structurées et non structurées en quantité illimitée. Composition de données structuréesrises stocker les données dans des tableaux et rows tandis que les données non structurées sont constituées d'images, de vidéos et de clips vocaux. En raison de l'augmentation du volume de données structurées et non structurées, la nécessité de Base de données NoSQL vient dans l'image.
Il offre aux développeurs une facilité de conception de schéma et une évolutivité platformulaire aux administrateurs de bases de données, il fournit un accès sécurisé et rapide platformulaire.
Qu'est-ce que MongoDB?
MongoDB est un outil cross-orienté orienté vers les documents.platformulaire et base de données NoSQL open source utilisée pour stocker des données semi-structurées écrites en C++. Au lieu de tableaux et rows, MongoDB stocke les données dans des paires clé-valeur. Pour rendre l'apprentissage facile et sans tracas pour les développeurs et les administrateurs, voici quelques-unes des commandes MongoDB fréquemment utilisées.
Commençons.
Commandes de base
1. Vérification de la version
La commande principale consiste à vérifier la version installée du serveur MongoDB et de Mongo Shell. Exécutez cette commande sur le terminal sous Linux ou à l'invite CMD sur windows.
mongod --version
C:\Windows\System32>mongod --version
db version v4.2.7
git version: 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
allocator: tcmalloc
modules: none
build environment:
distmod: 2012plus
distarch: x86_64
target_arch: x86_64
Nous pouvons aussi utiliser mongod
pour vérifier la version, comme suit.
mongo –version
C:\Windows\System32>mongo --version
MongoDB shell version v4.2.7
git version: 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
allocator: tcmalloc
modules: none
build environment:
distmod: 2012plus
distarch: x86_64
target_arch: x86_64
2. Liste des commandes MongoDB
Cette commande aidera les utilisateurs à découvrir toutes les commandes qui peuvent être utilisées dans MongoDB. Exécutez la commande sur Mongo Shell.
help()
mongo> db.help()
DB methods:
db.adminCommand(nameOrDocument) - switches to 'admin' db, and runs command [just calls db.runCommand(...)]
db.aggregate([pipeline], {options}) - performs a collectionless aggregation on this database; returns a cursor
db.auth(username, password)
db.cloneDatabase(fromhost) - will only function with MongoDB 4.0 and below
db.commandHelp(name) returns the help for the command
db.copyDatabase(fromdb, todb, fromhost) - will only function with MongoDB 4.0 and below
db.createCollection(name, {size: ..., capped: ..., max: ...})
db.createUser(userDocument)
db.createView(name, viewOn, [{$operator: {...}}, ...], {viewOptions})
db.currentOp() displays currently executing operations in the db
db.dropDatabase(writeConcern)
db.dropUser(username)
db.eval() - deprecated
db.fsyncLock() flush data to disk and lock server for backups
db.fsyncUnlock() unlocks server following a db.fsyncLock()
db.getCollection(cname) same as db['cname'] or db.cname
db.getCollectionInfos([filter]) - returns a list that contains the names and options of the db's collections
db.getCollectionNames()
db.getLastError() - just returns the err msg string
db.getLastErrorObj() - return full status object
db.getLogComponents()
db.getMongo() get the server connection object
db.getMongo().setSlaveOk() allow queries on a replication slave server
db.getName()
db.getProfilingLevel() - deprecated
db.getProfilingStatus() - returns if profiling is on and slow threshold
db.getReplicationInfo()
db.getSiblingDB(name) get the db at the same server as this one
db.getWriteConcern() - returns the write concern used for any operations on this db, inherited from server object if set
db.hostInfo() get details about the server's host
db.isMaster() check replica primary status
db.killOp(opid) kills the current operation in the db
db.listCommands() lists all the db commands
db.loadServerScripts() loads all the scripts in db.system.js
db.logout()
db.printCollectionStats()
db.printReplicationInfo()
db.printShardingStatus()
db.printSlaveReplicationInfo()
db.resetError()
db.runCommand(cmdObj) run a database command. if cmdObj is a string, turns it into {cmdObj: 1}
db.serverStatus()
db.setLogLevel(level,<component>)
db.setProfilingLevel(level,slowms) 0=off 1=slow 2=all
db.setVerboseShell(flag) display extra information in shell output
db.setWriteConcern(<write concern doc>) - sets the write concern for writes to the db
db.shutdownServer()
db.stats()
db.unsetWriteConcern(<write concern doc>) - unsets the write concern for writes to the db
db.version() current version of the server
db.watch() - opens a change stream cursor for a database to report on all changes to its non-system collections.
3. Statistiques DB
La commande ci-dessous donnera des détails sur les bases de données ainsi que plusieurs collections et related paramètres de cette base de données.
db.stats()
> db.stats()
{
"db" : "test",
"collections" : 0,
"views" : 0,
"objects" : 0,
"avgObjSize" : 0,
"dataSize" : 0,
"storageSize" : 0,
"numExtents" : 0,
"indexes" : 0,
"indexSize" : 0,
"scaleFactor" : 1,
"fileSize" : 0,
"fsUsedSize" : 0,
"fsTotalSize" : 0,
"ok" : 1
}
4. Créate Nouvelle base de données ou basculer vers une base de données existante
Cette commande simple aide à créerate une nouvelle base de données si elle n'existe pas ou aide à passer à la base de données existante. Dans MongoDB, « test » est la base de données par défaut, les utilisateurs utilisent donc «tester”DB une fois que Mongo Shell est connecté.
use DB_Name
mongos> use geekFlareDB
switched to db geekFlareDB
5. Liste de toutes les bases de données
La commande mentionnée est utilisée pour lister toutes les bases de données.
show dbs
mongo> show dbs
admin 0.000GB
config 0.002GB
geekFlareDB 0.000GB
test 0.000GB
6. Vérifiez la base de données actuellement utilisée
Exécutez la commande ci-dessous sur Mongo Shell pour voir la base de données actuellement utilisée.
db
> db
GeekFlare
7. Supprimer la base de données
La commande donnée aide l'utilisateur à supprimer la base de données requise. Exécutez la commande sur le client MongoDB. Assurez-vous de sélectionner la base de données avant d'exécuter la commande drop. Autrewise, il supprimera la valeur par défaut "tester" Base de données.
db.dropDatabase()
Commençons par lister toutes les bases de données, basculons vers l'une d'entre elles, puis déposons-la
> show dbs
admin 0.000GB
config 0.001GB
local 0.000GB
test 0.000GB
training 0.000GB
>
> use training
switched to db training
>
> db.dropDatabase()
{ "dropped" : "training", "ok" : 1 }
8. Créate Collection
Les collections sont similaires aux tables du SGBDR.
Create une commande de collection se compose de deux paramètres. La collection se compose de zero ou plusieurs documents. Par conséquent, pour créer une collection, le paramètre obligatoire à utiliser dans la commande est son nom et paramètre facultatif peut inclure le nom des documents, sa taille et son index.
- Créer une collection simple.
Syntaxe: db.createCollection(Name,Options)
Exemple:
> use geekFlare
switched to db geekFlare
>
> db.createCollection("geekFlareCollection")
{ "ok" : 1 }
>
> show collections
geekFlareCollection
- Créer une collection limitée
Dans ce cas, limitez la taille et le nombre de documents à insérer dans la collection. La collection plafonnée a une propriété pour supprimer les documents les plus anciens pour faire de la place pour les nouveaux documents.
Syntaxe:
db.createCollection(Name,{capped : true, size : sizeLimit , max : documentLimit })
Mise en situation : Créonsate une collection plafonnée, insérer un enregistrement et le récupérer
> db.createCollection("Login",{capped:true,max:1,size:200})
{ "ok" : 1 }
>
> db.Login.insertMany([{"id":1,status:"Active"},{"id":2,status:"Hold"},{"id":3,status:"Pending"}])
{
"acknowledged" : true,
"insertedIds" : [
ObjectId("5edc5f4f411247725e75e52e"),
ObjectId("5edc5f4f411247725e75e52f"),
ObjectId("5edc5f4f411247725e75e530")
]
}
>
> db.Login.find()
{ "_id" : ObjectId("5edc5f4f411247725e75e530"), "id" : 3, "status" : "Pending" }
9. Collecte des gouttes
La commande Drop Collection est similaire au DDL dans le SGBDR. Il acquiert des verrous sur la collection requise jusqu'à l'exécution de la commande. Drop collection supprime la collection de la base de données ainsi que tous les index associésated avec cette collection. Pour supprimer la collection, la méthode drop() est requise.
Il renvoie true pour une suppression réussie et false en cas d'erreur ou si la base de données n'existe pas.
Syntaxe: collectionName.drop()
Exemple:
> use geekFlare
switched to db geekFlare
>
> show collections
geekFlareCollection
>
> db.geekFlareCollection.drop()
true
>
> db.geekFlareCollection.drop()
false
Opérations CRUD related
10. Insérer le document dans la collection
Dans MongoDB, le document est similaire à un tuple dans le SGBDR.
Pour créerate un document, le insert()
méthode est utilisée. La méthode insert() créeates un ou plusieurs documents de la collection existante. Cela crée égalementates si elle n'est pas présente dans la base de données. Dans MongoDB, Document est sans schéma, cela signifie qu'il n'y a aucune restriction quant à l'insertion d'un nombre quelconque de clés dans un document.
- Insérer un seul enregistrement
Pour insérer un enregistrement insert()
or insertOne()
méthode peut être utilisée.
Syntaxe: collectionName.insertOne({document})
Exemple:
> db.geekFlareCollection.insertOne( {
code: "P123", Qty: 200, status: "Active"
});
{
"acknowledged" : true,
"insertedId" : ObjectId("5ed309725429283aee2e134d")
}
- Insertion de plusieurs enregistrements
Pour insérer de nombreux enregistrements, une liste d'enregistrements sera transmise à insert()
or insertMany()
méthode.
Syntaxe:
collectionName.insertMany([{document1},{document2},{ document3}….{ documentn}])
Exemple:
db.geekFlareCollection.insertMany([
... { code: "P1", Qty: 100, status: "Active"},
... { code: "P2", Qty: 200, status: "Active"},
... { code: "P3", Qty: 0, status: "Dective"}
... ]);
{
"acknowledged" : true,
"insertedIds" : [
ObjectId("5edf7b4e18b2c26b9dfe8cac"),
ObjectId("5edf7b4e18b2c26b9dfe8cad"),
ObjectId("5edf7b4e18b2c26b9dfe8cae")
]
}
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75b8"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75b9"), "product" : "bread", "Qty" : 20 }
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75ba"), "product" : "yogurt", "Qty" : 30 }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cac"), "code" : "P1", "Qty" : 100, "status" : "Active" }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cad"), "code" : "P2", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cae"), "code" : "P3", "Qty" : 0, "status" : "Dective" }
>
- Insérer un enregistrement en masse
Un grand nombre de documents peuvent également être insérés de manière ordonnée et non ordonnée en exécutant initializeOrderedBulkOp()
et le initializeUnorderedBulkOp()
méthodes.
Syntaxe:
var bulk = db.collectionName.initializeUnorderedBulkOp();
bulk.insert({document1} );
bulk.insert({document2} );
bulk.insert({documentn} );
bulk.execute();
Mise en situation :
> var bulk = db.geekFlareCollection.initializeUnorderedBulkOp();
> bulk.insert({ code: "P1", Qty: 100, status: "Active"});
> bulk.insert({ code: "P2", Qty: 200, status: "Active"});
> bulk.insert({ code: "P3", Qty: 0, status: "Dective"});
> bulk.execute();
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 3,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8caf"), "code" : "P1", "Qty" : 100, "status" : "Active" }
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8cb0"), "code" : "P2", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8cb1"), "code" : "P3", "Qty" : 0, "status" : "Dective" }
>
11. Récupérer le document d'une collection
Pour rechercher le document stocké dans une collection, la méthode find () peut être utilisée. La commande ci-dessous sera utilisée pour récupérer tous les documents de la collection.
find()
peut être utilisée pour récupérer tous les documents stockés dans une collection.
Syntaxe: collectionName.find()
Exemple:
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86ce"), "code" : "P1", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86cf"), "code" : "P2", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86d0"), "code" : "P3", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"), "code" : "P4", "Qty" : 100, "status" : "Inactive" }
find({condition})
peut être utilisée pour récupérer uniquement les documents requis en fonction de certaines conditions de la collection. MongoDB fournit une liste de opérateurs de projection et de requête pour récupérer la valeur de type BSON.
Syntaxe: collectionName.find({ condition })
Exemple:
> db.geekFlareCollection.find({ Qty: { $eq: 100 }});
{ "_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"), "code" : "P4", "Qty" : 100, "status" : "Inactive" }
- Pour récupérer un seul document, MongoDB fournit le
findOne
() méthode. Il donne une sortie formatée.
Syntaxe: collectionName.findOne()
Exemple:
> db.geekFlareCollection.findOne();
{
"_id" : ObjectId("5ed31186b6f2c2bb1edb86ce"),
"code" : "P1",
"Qty" : 200,
"status" : "Inactive"
}
12. Embellissez la sortie de récupération
La find()
méthode donne une sortie désorganisée. MongoDB fournit pretty()
commandes pour obtenir la sortie formatée.
Syntaxe: collectionName.find().pretty()
Exemple:
> db.geekFlareCollection.find({ Qty: { $eq: 100 }}).pretty();
{
"_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"),
"code" : "P4",
"Qty" : 100,
"status" : "Inactive"
}
13. Mise à jourate Document dans une collection
MongoDB fournit update()
méthode pour définir de nouvelles valeurs pour les clés existantes dans les documents. Mise à jourate La commande donne des détails sur les documents modifiés et correspondants. Syntaxe de mise à jourate la commande est:
Syntaxe: collectionName.update({KeyToUpdate},{Set Command})
Exemple:
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "product" : "bread", "Qty" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "product" : "yogurt", "Qty" : 30 }
>
> db.geekFlareCollection.update({"product" : "bottles"},{$set : {"Qty": 10}} )
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
>
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 10 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "product" : "bread", "Qty" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "product" : "yogurt", "Qty" : 30 }
>
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 10 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "product" : "bread", "Qty" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "product" : "yogurt", "Qty" : 30 }
updateOne()
: Pour mettre à jourate un seul document existeupdateOne()
méthode.updateOne()
donnez le nombre de documents appariés et modifiés.
Syntaxe: collectionName.updateOne({SingleKeyToUpdate},{Set Command})
Exemple:
> db.geekFlareCollection.updateOne({"product" : "bottles"},{$set : {"Qty": 40}} )
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
<strong>updateMany()</strong>
: Pour mettre à jourate plusieurs documents sous certaines conditions que MongoDB aupdateMany()
méthode.
Syntaxe: collectionName.updateMany({filter},{Set Command})
Exemple:
> db.geekFlareCollection.updateMany( { "Qty" : { $lt: 30 } },{ $set: { "Qty": "Inactive"} } )
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
14. Supprimer le document d'une collection
Pour supprimer le document, MongoDB se compose de deleteOne()
et le deleteMany()
méthodes. La syntaxe des méthodes de suppression est:
<strong>deleteOne({condition}) </strong>
supprime le document unique répondant aux critères de suppression.
Syntaxe: collectionName.deleteOne({DeletionCondition})
Exemple:
> db.geekFlareCollection.deleteOne({"product" : "bread"})
{ "acknowledged" : true, "deletedCount" : 1 }
<strong>deleteMany() </strong>
supprime tous les documents correspondant aux critères de suppression. Sans les critères de suppressiondeleteMany({condition})
supprime tous les documents.
syntaxe: collectionName.deleteMany({DeletionCondition})
Exemple:
> db.geekFlareCollection.deleteMany({"product" : "bottles"})
{ "acknowledged" : true, "deletedCount" : 2 }
<strong>remove() </strong>
Il existe une autre méthode pour supprimer tous les documents correspondant aux critères de suppression. remove () prend deux arguments, l'un est la condition de suppression et l'autre n'est qu'un indicateur.
Notes: La méthode Remove est obsolèteated dans les versions à venir.
Syntaxe: collectionName.remove({DeletionCondition},1)
Exemple:
> db.geekFlareCollection.remove({"product" : "bottles"})
WriteResult({ "nRemoved" : 1 })
15. Récupérer Distinct
La distinct()
méthode est utilisée pour obtenir des enregistrements uniques.
- Pour obtenir des enregistrements distincts à partir d'un champ.
Syntaxe: collectionName.distinct(field)
Exemple:
> db.geekFlareCollection.distinct("product")
[ "Cheese", "Snacks2", "Snacks3", "bread", "ketchup" ]
- Pour obtenir des enregistrements distincts à partir d'un champ tout en spécifiant la requête.
Syntaxe: collectionName.distinct(field,query)
Exemple:
> db.geekFlareCollection.distinct('product',{"Qty":20})
[ "Snacks3", "bread" ]
16. Renommer la collection
MongoDB fournit renameCollection ()
méthode pour renommer la collection.
Syntaxe: collectionName.renameCollection(newCollectionName)
Exemple:
>db.geekFlareCollection.renameCollection('geekFlareCol')
{ "ok" : 1 }
> show collections
geekFlareCol
Indexage
17. Créate Index sur le document
Les index sont une structure de données spéciale qui stocke une petite partie de l'ensemble de données de la collection sous une forme facile à parcourir. Les index prennent en charge l'ordre croissant et décroissant des valeurs des champs et facilitent ainsiate meilleures performances lors de la récupération.
MongoDB fournit le default_id
indice. De plus, MongoDB prend en charge le creation d’index définis par l’utilisateur. Les index MongoDB sont définis au niveau des collections et fournissent des supports au niveau du champ ou du sous-champ d'un document. Syntaxe de create l'indice est :
- Create un index sur un seul champ.
Syntaxe: collectionName.createIndex({Key:1})
En cela, l'indicateur cléates le champ sur lequel l'index est crééated et 1 signifient l’ordre croissant. Pour créerate un index par ordre décroissant -1 peut être utilisé.
Exemple:
> db.geekFlareCollection.createIndex({"product" : 1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
- Create un index sur plusieurs champs.
Syntaxe: collectionName.createIndex({Key1:1,key2:1…keyn:1})
Exemple:
> db.geekFlareCollection.createIndex({"product" : 1,"Qty":-1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
18. Afficher l'index sur le document
MongoDB fournit getIndexes()
méthode pour lister tous les index créésated sur un document.
Syntaxe: collectionName.getIndexes()
Exemple:
> db.geekFlareCollection.getIndexes()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "geekFlareCollection.geekFlareCollection"
}
]
19. Supprimer l'index du document
dropIndex()
est utilisée pour supprimer l'index unique et la méthode dropIndexes () est utilisée pour supprimer plusieurs index.
- Supprimer un index unique
Syntaxe: collectionName.dropIndex({key})
Exemple:
> db.geekFlareCollection.dropIndex({"product" : 1})
{ "nIndexesWas" : 3, "ok" : 1 }
- Supprimer plusieurs index.
Syntaxe: collectionName.dropIndexes({key1,key2…,keyN})
Exemple:
> db.geekFlareCollection.dropIndexes({"product" : 1,"Qty":-1})
{ "nIndexesWas" : 3, "ok" : 1 }
Récupération related
20. Limiter la récupération des documents
limit()
permet de limiter le nombre de documents renvoyés. La méthode limit () accepte les arguments numériques.
Syntaxe: collectionName.find().limit(number)
Exemple:
> db.geekFlareCollection.find().limit(2)
{ "_id" : ObjectId("5ed3c9e7b6f2c2bb1edb8702"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5ed3c9e7b6f2c2bb1edb8703"), "product" : "bread", "Qty" : 20 }
21. Ignorer la récupération des documents
MongoDB prend en charge skip()
méthode. Cette méthode ignore le nombre requis de documents. Il accepte un argument numérique.
Syntaxe: collectionName.find().skip(number)
Exemple:
> db.geekFlareCollection.find().skip(2)
{ "_id" : 3, "product" : "yogurt", "Qty" : 30 }
> db.geekFlareCollection.find().skip(3)
22. Trier la récupération des documents
MongoDB sort()
méthode trie les documents de sortie par ordre croissant ou décroissant. Cette méthode accepte le nom des clés avec le nombre pour spécifier l'ordre de tri 1 est utilisé pour l'ordre croissant tandis que -1 est utilisé pour spécifier l'ordre décroissant.
Syntaxe: collectionName.find().sort({key:1})
Exemple:
> db.geekFlareCollection.find().sort({"Qty":1})
{ "_id" : 2, "product" : "bread", "Qty" : 20 }
{ "_id" : 3, "product" : "yogurt", "Qty" : 30 }
{ "_id" : 1, "product" : "bottles", "Qty" : 100 }
Validation related
23. Validation des documents
Les validateurs aident à restreindre le type de données insérées dans les documents. Les validateurs sont définis lors de la collecte. Validateur creation est requis pour utiliser le mot-clé validateur et facultatif niveau de validation et le action de validation pour spécifier le mode de validation. La validation du document ne limite pas l'insertion du nouveau champ dans le document.
Syntaxe: createCollection(“collectionName”,{validator:{ fields condition }})
Mise en situation :
> db.createCollection( "Login",
... { validator: { $and:
... [
... { phone: { $type: "string" } },
... { email: { $regex: /@flares\.com$/ } },
... { status: { $in: [ "Registered", "Unknown" ] } }
... ]
... }
... } )
{ "ok" : 1 }
>
> db.Login.insert({phone:1234})
WriteResult({
"nInserted" : 0,
"writeError" : {
"code" : 121,
"errmsg" : "Document failed validation"
}
})
>
> db.Login.insert({phone:"1234",email:"abc@flares.com",status:"Unknown",mode:"limited"})
WriteResult({ "nInserted" : 1 })
24. Validateurs de schéma sur une nouvelle collection
Mot clé supplémentaire $ jsonSchema avec propriétés supplémentaires valeur comme Faux est nécessaire pour mettre une restriction au niveau du schéma. C'est prevents nouveaux champs à ajouter dans le document.
Syntaxe: createCollection(“collectionName”,{validator: { $jsonSchema { schema condition } }})
Exemple:
> db.createCollection( "Login", {
... validator: { $jsonSchema: {
... bsonType: "object",
... "additionalProperties": false,
... required: [ "email" ],
... properties: {
... email: {
... bsonType : "string",
... pattern : "@flares\.com$",
... description: "string meets the given expression"
... },
... status: {
... enum: [ "registered", "Invalid" ],
... description: "status must be within enum values"
... }
... }
... } },
... } )
{ "ok" : 1 }
>
> db.Login.insert({email:"abc@flares.com"})
WriteResult({
"nInserted" : 0,
"writeError" : {
"code" : 121,
"errmsg" : "Document failed validation"
}
})
25. Mise à jourate ou Create Validateurs de schéma sur une collection existante
Un validateur peut être crééated sur la collection existante en utilisant collMod
Syntaxe: runCommand({collMod:”collectionName”,validator:{schema condition}})
Mise en situation :
> db.runCommand( {
collMod: "Login",
validator: { $jsonSchema: {
bsonType: "object",
"additionalProperties": false,
required: [ "email","status" ],
properties: {
email: {
bsonType : "string",
pattern : "@flares\.com$",
description: "string meets the given expression"
},
status: {
enum: [ "registered", "Invalid" ],
description: "status must be within enum values"
}
}
} },
validationAction: "error",
validationLevel: "strict"
} )
{ "ok" : 1 }
26. Supprimer les validateurs de schéma sur une collection existante
Pour supprimer les validateurs de schéma, il faut définir <strong>validationLevel</strong>
comme off.
Syntaxe: runCommand({collMod:”collectionName”,validator:{ },validationLevel:off})
Exemple:
> db.runCommand({
collMod:"Login",
validator:{},
validationLevel:"off"
})
{ "ok" : 1 }
>
> db.Login.insert({"email":"abc"})
WriteResult({ "nInserted" : 1 })
27. Rechercher des validateurs sur une collection existante
Pour vérifier si la collection existante a des validateurs de schéma exécutés ci-dessous la commande. Sans spécifier le nom de la collection db.getCollectionInfos()
La méthode donne des détails sur les validateurs sur toutes les collections résidant dans une base de données.
Syntaxe: getCollectionInfos({name : “collectionName”})
Exemple:
> db.getCollectionInfos({name: "Login"})
[
{
"name" : "Login",
"type" : "collection",
"options" : {
"validator" : {
"email" : {
"$regex" : /@flares\.com$/
}
}
},
"info" : {
"readOnly" : false,
"uuid" : UUID("646674f6-4b06-466d-93b0-393b5f5cb4ff")
},
"idIndex" : {
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "geekFlareDB.Login"
}
}
]
Curseurs related
28. Curseur dans MongoDB
Le curseur est un pointeur vers iterate sur l’ensemble de résultats. MongoDB utilise <strong>hasNext()</strong>
et le <strong>forEach()</strong>
méthode d'itération. Une liste de méthodes de curseur a été fourni.
Exemples:
> var newCursor=db.geekFlareCollection.find() > newCursor.forEach(printjson) { "_id" : 1, "product" : "bottles", "Qty" : 100 } { "_id" : 2, "product" : "bread", "Qty" : 20 } { "_id" : 3, "product" : "yogurt", "Qty" : 30 } > > var newCursor1=db.geekFlareCollection.find() > while(newCursor1.hasNext()){ printjson(newCursor1.next())} { "_id" : 1, "product" : "bottles", "Qty" : 100 } { "_id" : 2, "product" : "bread", "Qty" : 20 } { "_id" : 3, "product" : "yogurt", "Qty" : 30
utilitaire
29. Sauvegarde de la base de données
mongodump
L'utilitaire est utilisé pour exporter le contenu de la base de données MongoDB en tant que sauvegarde. Cette commande s'exécute depuis la console système et non depuis le shell mongo. Cela généreraate sauvegarde binaire avec informations de métadonnées.
Syntaxe:
mongodump --db dbName --out outFile --host "IP:PORT" --username <user> --password <pass>
Mise en situation :
C:\mongodb\dump>mongodump --db geekFlareDB --out "C:\mongodb\dump" --host "127.0.0.1:27017"
2020-06-02T12:26:34.428+0530 writing geekFlareDB.myTable to
2020-06-02T12:26:34.430+0530 writing geekFlareDB.geekFlareCollection to
2020-06-02T12:26:34.430+0530 writing geekFlareDB.mCollection to
2020-06-02T12:26:34.433+0530 writing geekFlareDB.users to
2020-06-02T12:26:34.434+0530 done dumping geekFlareDB.myTable (2 documents)
2020-06-02T12:26:34.434+0530 done dumping geekFlareDB.geekFlareCollection (4 documents)
2020-06-02T12:26:34.435+0530 writing geekFlareDB.contacts2 to
2020-06-02T12:26:34.435+0530 writing geekFlareDB.Login to
2020-06-02T12:26:34.436+0530 done dumping geekFlareDB.mCollection (2 documents)
2020-06-02T12:26:34.437+0530 done dumping geekFlareDB.users (1 document)
2020-06-02T12:26:34.437+0530 done dumping geekFlareDB.Login (0 documents)
2020-06-02T12:26:34.438+0530 done dumping geekFlareDB.contacts2 (0 documents)
30. Restauration de la base de données à partir de la sauvegarde
l'utilitaire <strong>mongorestore</strong>
est utilisé pour restaurer le générateur de données binairesated par mongodump
.
Syntaxe: mongorestore --db newDB "pathOfOldBackup"
Exemple:
C:\Users\asad.ali>mongorestore --db geekFlareNew "C:\mongodb\dump\geekFlare" --host "127.0.0.1:27017"
2020-06-09T15:49:35.147+0530 the --db and --collection args should only be used when restoring from a BSON file. Other uses are deprecated and will not exist in the future; use --nsInclude instead
2020-06-09T15:49:35.148+0530 building a list of collections to restore from C:\mongodb\dump\geekFlare dir
2020-06-09T15:49:35.152+0530 reading metadata for geekFlareNew.geekFlareCollection from C:\mongodb\dump\geekFlare\geekFlareCollection.metadata.json
2020-06-09T15:49:35.321+0530 restoring geekFlareNew.geekFlareCollection from C:\mongodb\dump\geekFlare\geekFlareCollection.bson
2020-06-09T15:49:35.461+0530 no indexes to restore
2020-06-09T15:49:35.462+0530 finished restoring geekFlareNew.geekFlareCollection (3 documents, 0 failures)
2020-06-09T15:49:35.467+0530 3 document(s) restored successfully. 0 document(s) failed to restore.
31. Exportation de collections
Pour exporter le contenu de la collection vers un fichier (JSON ou CSV) mongoexport
l'utilité a été fournie. Pour exécuter cette commande, utilisez le terminal système.
- Exportez une seule collection vers un fichier.
Syntaxe: mongoexport --db dbName --collection collectionName --out outputFile
Exemple:
C:\mongodb\New folder>mongoexport --db geekFlareDB --collection geekFlareCol --out outFile.json
2020-06-06T19:02:29.994+0530 connected to: mongodb://localhost/
2020-06-06T19:02:30.004+0530 exported 6 records
- Exportez un champ spécifique de la collection vers un fichier.
Syntaxe: mongoexport --db dbName --collection collectionName --out outputFile --fields fieldname
Exemple:
C:\mongodb\New folder>mongoexport --db geekFlareDB --collection geekFlareCol --out outFile.json --fields product
2020-06-06T19:05:22.994+0530 connected to: mongodb://localhost/
2020-06-06T19:05:23.004+0530 exported 6 records
32. Importation de collections
Pour importer des données depuis un fichier (CSV ou JSON) mongoimport
l'outil de ligne de commande peut être utilisé.
Syntaxe: mongoimport --db dbName --collection collectionName --file inputFile
C:\Users\asad.ali>mongoimport --db geekFlareDB --collection geekFlareNew --file outFile.json
2020-06-09T14:52:53.655+0530 connected to: mongodb://localhost/
2020-06-09T14:52:53.924+0530 6 document(s) imported successfully. 0 document(s) failed to import.
Réplique related
La réplication est différente du sharding, consultez ce guide pour implémenter le partage.
33. Réplication MongoDB
La réplication est la process à syncSynchronisez les données sur plusieurs serveurs. C'est prevperte de données suite à un dysfonctionnement du matériel ou du logiciel. MongoDB réalise la réplication à l'aide d'ensembles de réplicas. Le jeu de réplicas se compose d'ensembles de données Mongo primaires et secondaires dans le cluster.
L’ensemble de données primaire accepte toutes les opérations d’écriture et les lectures d’ensembles de données secondaires à partir du primaire. Au moins 3 ensembles de données sont requis dans l'ensemble Mongo Replica. Ci-dessous process est requis pour configurer un jeu de réplicas :
- Accueil
mongod
serveur avecreplset
option sur un minimum de 3 nœuds.
mongod --port 27017 --dbpath C:\data\data1 --replSet rs0 --oplogSize 128
mongod --port 27018 --dbpath C:\data\data1 --replSet rs0 --oplogSize 128
mongod --port 27019 --dbpath C:\data\data1 --replSet rs0 --oplogSize 128
- Initialisez le jeu de réplicas.
rs.initiate( { _id : "rs0", members: [ { _id: 0, host: "IP:27017" }, { _id: 1, host: "IP:27018" }, { _id: 2, host: "IP:27019" } ] })
> rs.initiate( {
... _id : "rs0",
... members: [
... { _id: 0, host: "localhost:27017" },
... { _id: 1, host: "localhost:27018" },
... { _id: 2, host: "localhost:27019" }
... ]
... })
{
"ok" : 1,
"$clusterTime" : {
"clusterTime" : Timestamp(1591089166, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
},
"operationTime" : Timestamp(1591089166, 1)
}
34. Vérifier l'état de la réplication
Exécutez la commande ci-dessous à partir du nœud de réplica principal pour obtenir des informations complètes sur l'ensemble de répliques.
rs.conf()
rs.status()
rs0:PRIMARY> rs.conf()
{
"_id" : "rs0",
"version" : 2,
"protocolVersion" : NumberLong(1),
"writeConcernMajorityJournalDefault" : true,
"members" : [
{
"_id" : 0,
"host" : "localhost:27017",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 1,
"host" : "localhost:27018",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 2,
"host" : "localhost:27019",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 3,
"host" : "localhost:27016",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
}
],
"settings" : {
"chainingAllowed" : true,
"heartbeatIntervalMillis" : 2000,
"heartbeatTimeoutSecs" : 10,
"electionTimeoutMillis" : 10000,
"catchUpTimeoutMillis" : -1,
"catchUpTakeoverDelayMillis" : 30000,
"getLastErrorModes" : {
},
"getLastErrorDefaults" : {
"w" : 1,
"wtimeout" : 0
},
"replicaSetId" : ObjectId("5ed6180d01a39f2162335de5")
}
}
35. Ajouter une nouvelle instance MongoDB à un jeu de réplicas
Démarrez le client MongoDB principal et exécutez la commande ci-dessous
Syntaxe: rs.add(“hostname:port”)
Exemple:
rs0:PRIMARY> rs.add("localhost:27016")
{
"ok" : 1,
"$clusterTime" : {
"clusterTime" : Timestamp(1591094195, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
},
"operationTime" : Timestamp(1591094195, 1)
}
36. Supprimer l'instance MongoDB existante du jeu de réplicas
La commande ci-dessous supprimera l'hôte secondaire requis du jeu de réplicas.
Syntaxe: rs.remove("localhost:27017")
Exemple:
rs0:PRIMARY> rs.remove("localhost:27016")
{
"ok" : 1,
"$clusterTime" : {
"clusterTime" : Timestamp(1591095681, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
},
"operationTime" : Timestamp(1591095681, 1)
}
rs0:PRIMARY>
37. Faire du primaire comme jeu de réplicas secondaire
MongoDB fournit une commande pour demander au réplica principal de devenir un jeu de réplicas secondaire.
Syntaxe: rs.stepDown( stepDownSecs , secondaryCatchupSecs )
Exemple:
rs0:PRIMARY> rs.stepDown(12)
{
"ok" : 1,
"$clusterTime" : {
"clusterTime" : Timestamp(1591096055, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
},
"operationTime" : Timestamp(1591096055, 1)
}
rs0:SECONDARY>
38. Vérifiez le décalage de réplique entre le primaire et le secondaire
La commande ci-dessous sera utilisée pour vérifier le décalage de réplication entre tous les jeux de réplicas du primaire.
Syntaxe: rs.printSlaveReplicationInfo()
Exemple:
rs0:PRIMARY> rs.printSlaveReplicationInfo()
source: localhost:27018
syncedTo: Tue Jun 02 2020 16:14:04 GMT+0530 (India Standard Time)
0 secs (0 hrs) behind the primary
source: localhost:27019
syncedTo: Thu Jan 01 1970 05:30:00 GMT+0530 (India Standard Time)
1591094644 secs (441970.73 hrs) behind the primary
source: localhost:27016
syncedTo: Tue Jun 02 2020 16:14:04 GMT+0530 (India Standard Time)
0 secs (0 hrs) behind the primary
rs0:PRIMARY>
Transactions related
39. Transactions dans MongoDB
MongoDB prend en charge les propriétés ACID pour les transactions sur les documents.
Pour démarrer une transaction, une session est requise pour démarrer et une validation est requise pour enregistrer les modifications dans la base de données. Les transactions sont prises en charge sur les jeux de répliques ou les mangues. Une fois la session validée, les opérations effectuées à l'intérieur de la session seront visibles à l'extérieur.
- Démarrer la session
Syntaxe: session =
db.getMongo().startSession()
- Commencer la transaction,
Syntaxe: session.startTransaction()
- Valider la transaction
Syntaxe: session.commitTransaction()
Exemple:
Créonsate une session, démarrer la transaction, effectuer quelques insertions/mises à jourate puis validez la transaction.
rs0:PRIMARY> session = db.getMongo().startSession()
session { "id" : UUID("f255a40d-81bd-49e7-b96c-9f1083cb4a29") }
rs0:PRIMARY> session.startTransaction()
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.insert([
... {_id: 4 , product: "ketchup"},
... {_id: 5, product: "Cheese"}
... ]);
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 2,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
{ "_id" : 4, "product" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }
rs0:PRIMARY> db.geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
rs0:PRIMARY> session.commitTransaction()
rs0:PRIMARY> db.geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
{ "_id" : 4, "product" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
{ "_id" : 4, "product" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }
40. Conflit de transactions sur un seul document
Si deux transactions ont tenté de mettre à jourate le même document, MongoDB erows erreur de conflit d'écriture.
session1.startTransaction()
session2.startTransaction()
Effectuer quelques insertions/mises à jourate sur Session1 suivi de sur Session2. Observez maintenant l'erreur dans l'exemple ci-dessous
Exemple:
rs0:PRIMARY> session1.startTransaction()
rs0:PRIMARY> session2.startTransaction()
rs0:PRIMARY> session1.getDatabase("geekFlareDB").geekFlareCollection.update({_id:3},{$set:{ product: "Bread" }})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
rs0:PRIMARY> session2.getDatabase("geekFlareDB").geekFlareCollection.update({_id:3},{$set:{ product: "Snacks" }})
WriteCommandError({
"errorLabels" : [
"TransientTransactionError"
],
"operationTime" : Timestamp(1591174593, 1),
"ok" : 0,
"errmsg" : "WriteConflict",
"code" : 112,
"codeName" : "WriteConflict",
"$clusterTime" : {
"clusterTime" : Timestamp(1591174593, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
})
rs0:PRIMARY>
41. Transactions multi-documents
MongoDB prend en charge les transactions multi-documents en une seule session.
- db.getMongo ().startTransaction ()
Effectuer quelques insertions/mises à jourate sur plusieurs documents
- session.commitTransaction ()
Exemple:
rs0:PRIMARY> var session = db.getMongo().startSession()
rs0:PRIMARY> session.startTransaction()
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.update({_id:3},{$set:{ product: "Snacks3" }})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 0 })
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.update({_id:2},{$set:{ product: "Snacks2" }})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 0 })
rs0:PRIMARY> session.commitTransaction()
rs0:PRIMARY> db.geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "Snacks2", "Qty" : 100 }
{ "_id" : 3, "product" : "Snacks3", "Qty" : 20 }
{ "_id" : 4, "product" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }
rs0:PRIMARY>
42. Profiling dans MongoDB
Profiling aide à enregistrer les requêtes lentes dans le system.profile
collecte. Profiniveau supérieur et échantillon rate définir le pourcentage de requêtes à connecter system.profile
collecte.
- Définir/Obtenir Profiniveau de linge
Syntaxe:
db.setProfilingLevel(profilingLevel,{"slowms":time,"sampleRate":LoggingPercentage})
> db.setProfilingLevel(2,{"slowms":1,"sampleRate":1})
{ "was" : 1, "slowms" : 1, "sampleRate" : 0.5, "ok" : 1 }
>
> db.getProfilingLevel()
2
- Gagnez Profistatut ling
Syntaxe: db.getProfilingStatus()
> db.getProfilingStatus()
{ "was" : 2, "slowms" : 1, "sampleRate" : 1 }
- Autoriser profiling au niveau de l'instance MongoDB, démarrez l'instance avec profiler informations ou ajouter profiles détails du fichier de configuration.
Syntaxe:
mongod --profile <Level> --slowms <time> --slowOpSampleRate <%Logging>
Exemple:
C:\Windows\System32>mongod --port 27017 --dbpath C:\data\data1 --profile 1 --slowms 25 --slowOpSampleRate 0.5
2020-06-09T02:34:41.110-0700 I CONTROL [main] Automatically disabling TLS 1.0, to force-enable TLS 1.0 specify --sslDisabledProtocols 'none'
2020-06-09T02:34:41.113-0700 W ASIO [main] No TransportLayer configured during NetworkInterface startup
2020-06-09T02:34:41.113-0700 I CONTROL [initandlisten] MongoDB starting : pid=22604 port=27017 dbpath=C:\data\data1 64-bit host=MCGL-4499
2020-06-09T02:34:41.114-0700 I CONTROL [initandlisten] targetMinOS: Windows 7/Windows Server 2008 R2
2020-06-09T02:34:41.116-0700 I CONTROL [initandlisten] db version v4.2.7
2020-06-09T02:34:41.116-0700 I CONTROL [initandlisten] git version: 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
43. MongoDB Explain ()
MongoDB explains()
La méthode renvoie des statistiques et fournit des informations pour sélectionner un plan gagnant et l'exécuter jusqu'à son terme. Il renvoie les résultats selon le plan de verbosité.
Syntaxe: collectionName.explain(“verbosityName”)
Pour exécuter la méthode/commande expliquer(), créonsate a verbosité puis exécutez la méthode explic (), jetez un œil à l'exemple ci-dessous, où ces étapes ont été exécutées.
Exemple:
> db.runCommand(
... {
... explain: { count: "product", query: { Qty: { $gt: 10 } } },
... verbosity: "executionStats"
... }
... )
{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "test.product",
"indexFilterSet" : false,
"winningPlan" : {
"stage" : "COUNT",
"inputStage" : {
"stage" : "EOF"
}
},
"rejectedPlans" : [ ]
},
"executionStats" : {
"executionSuccess" : true,
"nReturned" : 0,
"executionTimeMillis" : 47,
"totalKeysExamined" : 0,
"totalDocsExamined" : 0,
"executionStages" : {
"stage" : "COUNT",
"nReturned" : 0,
"executionTimeMillisEstimate" : 0,
"works" : 1,
"advanced" : 0,
"needTime" : 0,
"needYield" : 0,
"saveState" : 0,
"restoreState" : 0,
"isEOF" : 1,
"nCounted" : 0,
"nSkipped" : 0,
"inputStage" : {
"stage" : "EOF",
"nReturned" : 0,
"executionTimeMillisEstimate" : 0,
"works" : 0,
"advanced" : 0,
"needTime" : 0,
"needYield" : 0,
"saveState" : 0,
"restoreState" : 0,
"isEOF" : 1
}
}
},
"serverInfo" : {
"host" : "MCGL-4499",
"port" : 27017,
"version" : "4.2.7",
"gitVersion" : "51d9fe12b5d19720e72dcd7db0f2f17dd9a19212"
},
"ok" : 1
}
>
> var expv = db.geekFlareCol.explain("executionStats")
> expv.find( { product: "bread"} )
{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "geekFlareDB.geekFlareCol",
"indexFilterSet" : false,
"parsedQuery" : {
"product" : {
"$eq" : "bread"
}
},
"winningPlan" : {
"stage" : "COLLSCAN",
"filter" : {
"product" : {
"$eq" : "bread"
}
},
"direction" : "forward"
},
"rejectedPlans" : [ ]
},
"executionStats" : {
"executionSuccess" : true,
"nReturned" : 2,
"executionTimeMillis" : 0,
"totalKeysExamined" : 0,
"totalDocsExamined" : 6,
"executionStages" : {
"stage" : "COLLSCAN",
"filter" : {
"product" : {
"$eq" : "bread"
}
},
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"works" : 8,
"advanced" : 2,
"needTime" : 5,
"needYield" : 0,
"saveState" : 0,
"restoreState" : 0,
"isEOF" : 1,
"direction" : "forward",
"docsExamined" : 6
}
},
"serverInfo" : {
"host" : "MCGL-4499",
"port" : 27017,
"version" : "4.2.7",
"gitVersion" : "51d9fe12b5d19720e72dcd7db0f2f17dd9a19212"
},
"ok" : 1
}
>
Contrôle d'accès related
44. Contrôle d'accès dans MongoDB
Les fonctionnalités de contrôle d'accès permettent l'authentification de l'accès aux utilisateurs existants. Pour que le contrôle d'accès soit activé, la base de données garantit la créationate un rôle d'administrateur utilisateur dans la base de données admin.
- Connectez DB sans authentification.
- Passer à la base de données
use admin
- Create utilisateur comme ci-dessous
db.createUser( {user: “UserAdmin”, pwd: “password” ,role: [adminRole])
Mise en situation :
db.createUser(
... {
... user: "AdminUser",
... pwd: passwordPrompt(),
... roles: [ { role: "userAdminAnyDatabase", db: "admin" }, "readWriteAnyDatabase" ]
... }
... )
Enter password:
Successfully added user: {
"user" : "AdminUser",
"roles" : [
{
"role" : "userAdminAnyDatabase",
"db" : "admin"
},
"readWriteAnyDatabase"
]
}
- Recommencer
mongod
instance - Accédez à nouveau avec created utilisateur et mot de passe.
C:\Users\>mongo --port 27017 --authenticationDatabase "admin" -u "AdminUser" -p
MongoDB shell version v4.2.7
Enter password:
connecting to: mongodb://127.0.0.1:27017/?authSource=admin&compressors=disabled&gssapiServiceName=mongodb
45. Récupérer et supprimer l'utilisateur du contrôle d'accès
La commande ci-dessous peut être utilisée pour vérifier les informations de l'utilisateur et les supprimer.
db.getUser("AdminUser")
db.dropUser("AdminUser")
Exemple:
> db.getUser("AdminUser")
{
"_id" : "admin.AdminUser",
"userId" : UUID("78d2d5bb-0464-405e-b27e-643908a411ce"),
"user" : "AdminUser",
"db" : "admin",
"roles" : [
{
"role" : "userAdminAnyDatabase",
"db" : "admin"
},
{
"role" : "readWriteAnyDatabase",
"db" : "admin"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}
> db.dropUser("AdminUser")
true
> db.getUser("AdminUser")
null
>
46. Attribuer des rôles définis par l'utilisateur
MongoDB fournit db.createRole()
pour spécifier les privilèges d'un utilisateur et un tableau de rôles hérités.
- Connectez l'instance MongoDB à l'utilisateur admin.
- Exécutez la commande ci-dessous pour générerate un nouveau rôle.
Syntaxe:
db.createRole({role:”roleName”,privileges:[{privilegeName}],roles:[InheritedArray]})
Exemple:
use admin
> db.createRole(
... {
... role: "abc",
... privileges: [ { resource: { db: "geekFlareDB", collection: "geekFlareCol" }, actions: [ "killop" ,"inprog"] } ],
... roles: []
... }
... )
{
"role" : "abc",
"privileges" : [
{
"resource" : {
"db" : "geekFlareDB",
"collection" : "geekFlareCol"
},
"actions" : [
"killop",
"inprog"
]
}
],
"roles" : [ ]
}
47. Revoke Rôles définis par l'utilisateur
Pour modifier les rôles existants, utilisez la commande ci-dessous.
Syntaxe: db.revokeRolesFromUser( userName, [{ "role" : roleName , db:dbName} ] )
Exemple:
> db.getUser("AdminUser")
{
"_id" : "admin.AdminUser",
"userId" : UUID("fe716ed1-6771-459e-be13-0df869c91ab3"),
"user" : "AdminUser",
"db" : "admin",
"roles" : [
{
"role" : "userAdminAnyDatabase",
"db" : "admin"
},
{
"role" : "readWriteAnyDatabase",
"db" : "admin"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}
> db.revokeRolesFromUser( "AdminUser", [{ "role" : "userAdminAnyDatabase" , db:"admin"} ] )
> db.getUser("AdminUser")
{
"_id" : "admin.AdminUser",
"userId" : UUID("fe716ed1-6771-459e-be13-0df869c91ab3"),
"user" : "AdminUser",
"db" : "admin",
"roles" : [
{
"role" : "readWriteAnyDatabase",
"db" : "admin"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}
>
48. Connectivité MongoDB avec Python
Le package pymongo est requis pour connecter MongoDB à partir de la console python.
>>> from pymongo import MongoClient
>>> mClient=MongoClient("mongodb://127.0.0.1:27017/")
>>> mDB=mClient.geekFlareDB
>>> mRecord={"_id":4,"name":"XYZ"}
>>> mDB.geekFlareCollection.insert_one(mRecord)
<pymongo.results.InsertOneResult object at 0x000002CC44256F48>
>>> for i in mDB.geekFlareCollection.find({"_id":4}):
... print(i)
...
{'_id': 4, 'name': 'XYZ'}
>>>
Quelle est la prochaine?
Consultez cette liste de Clients NoSQL pour gérer MongoDB et d'autres bases de données NoSQL. Si votre travail implique de travailler fréquemment sur MongoDB, vous voudrez peut-être en savoir plus Cours Udemy.