Este artículo habla sobre las consultas y comandos de uso frecuente de MongoDB utilizado por desarrolladores y DBA en su desarrollo diario y vida operativa.
Quick Intro
En esta nueva era de tecnología inteligente, los datos se generan en un gran volumen y cada dato es igualmente importante para las industrias en crecimiento. Los usuarios están generando datos estructurados, semiestructurados y no estructurados en una cantidad ilimitada. Los datos estructurados comprenden el almacenamiento de datos en tablas y filas, mientras que los datos no estructurados consisten en imágenes, videos y clips de voz. Debido al creciente volumen de datos de datos estructurados y no estructurados, es necesario Base de datos NoSQL entra en la imagen.
Proporciona a los desarrolladores facilidad para diseñar esquemas y plataformas escalables a los administradores de bases de datos, proporciona una plataforma segura y rápida.
What is MongoDB?
MongoDB es una base de datos NoSQL de código abierto, multiplataforma y orientada a documentos que se utiliza para almacenar datos semiestructurados escritos en C ++. En lugar de tablas y filas, MongoDB almacena datos en pares clave-valor. Para que el aprendizaje sea fácil y sin complicaciones para los desarrolladores y administradores, estos son algunos de los comandos de MongoDB de uso frecuente.
Vamos a ponerlo en marcha.
Basic Commands
1. Verificación de la versión
El comando más importante es verificar la versión instalada del servidor MongoDB y Mongo Shell. Ejecute este comando en el terminal en Linux o en el indicador CMD en 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
También podemos usar mongod
comando para verificar la versión, de la siguiente manera.
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. Listado de comandos de MongoDB
Este comando ayudará a los usuarios a descubrir todos los comandos que se pueden usar en MongoDB. Ejecute el comando en 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. Estadísticas de base de datos
El siguiente comando proporcionará detalles de las bases de datos junto con varias colecciones y parámetros relacionados de esa base de datos.
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. Cree una nueva base de datos o cambie a una base de datos existente
Este comando simple ayuda a crear una nueva base de datos si no existe o ayuda a cambiar a la base de datos existente. En MongoDB, "prueba" es la base de datos predeterminada, por lo que los usuarios usan "test”DB una vez que se inicie sesión en Mongo Shell.
use DB_Name
mongos> use geekFlareDB
switched to db geekFlareDB
5. Listado de todas las bases de datos
El comando mencionado se utiliza para enumerar todas las bases de datos.
show dbs
mongo> show dbs
admin 0.000GB
config 0.002GB
geekFlareDB 0.000GB
test 0.000GB
6. Verifique la base de datos actualmente en uso
Ejecute el siguiente comando en Mongo Shell para ver la base de datos actualmente en uso.
db
> db
GeekFlare
7. Eliminar base de datos
El comando dado ayuda al usuario a eliminar la base de datos requerida. Ejecute el comando en el cliente MongoDB. Asegúrese de seleccionar la base de datos antes de ejecutar el comando drop. De lo contrario, eliminará el valor predeterminado "test”Base de datos.
db.dropDatabase()
Primero enumeremos toda la base de datos, cambiemos a una de ellas y luego suéltela
> 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. Crear colección
Las colecciones son similares a las tablas en RDBMS.
El comando Crear una colección consta de dos parámetros. La colección consta de cero o más documentos. Por lo tanto, para crear una colección, el parámetro obligatorio para usar en el comando es su nombre y parámetro opcional puede incluir el nombre de los documentos, su tamaño y su índice.
- Creando una colección sencilla.
Sintaxis: db.createCollection(Name,Options)
Ejemplo:
> use geekFlare
switched to db geekFlare
>
> db.createCollection("geekFlareCollection")
{ "ok" : 1 }
>
> show collections
geekFlareCollection
- Creación de una colección limitada
En esto, restrinja el tamaño y la cantidad de documentos que se insertarán en la colección. La colección limitada tiene la propiedad de eliminar los documentos más antiguos para dejar espacio para los documentos nuevos.
Sintaxis:
db.createCollection(Name,{capped : true, size : sizeLimit , max : documentLimit })
Ejemplo: Creemos una colección limitada, insertemos un registro y recuperémoslo
> 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. Recogida de gotas
El comando Drop Collection es similar a DDL en RDBMS. Adquiere bloqueos en la colección requerida hasta la ejecución del comando. Drop collection elimina la colección de la base de datos junto con todos los índices asociados con esa colección. Para eliminar la colección, se requiere el método drop ().
Devuelve verdadero para una caída exitosa y falso en caso de cualquier error o si la base de datos no existe.
Sintaxis: collectionName.drop()
Ejemplo:
> use geekFlare
switched to db geekFlare
>
> show collections
geekFlareCollection
>
> db.geekFlareCollection.drop()
true
>
> db.geekFlareCollection.drop()
false
CRUD Operations related
10. Inserte el documento en la colección
En MongoDB, el documento es similar a una tupla en RDBMS.
Para crear un documento, el insert()
se utiliza el método. El método insert () crea uno o varios documentos en la colección existente. También crea una colección si no está presente en la base de datos. En MongoDB, Document no tiene esquema, lo que significa que no hay restricciones para insertar cualquier número de claves en un documento.
- Insertar un solo registro
Para insertar un registro insert()
or insertOne()
se puede utilizar el método.
Sintaxis: collectionName.insertOne({document})
Ejemplo:
> db.geekFlareCollection.insertOne( {
code: "P123", Qty: 200, status: "Active"
});
{
"acknowledged" : true,
"insertedId" : ObjectId("5ed309725429283aee2e134d")
}
- Insertar varios registros
Para insertar muchos registros, se pasará una lista de registros a insert()
or insertMany()
método.
Sintaxis:
collectionName.insertMany([{document1},{document2},{ document3}….{ documentn}])
Ejemplo:
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" }
>
- Insertar registro a granel
También se puede insertar una gran cantidad de documentos de forma ordenada y desordenada ejecutando initializeOrderedBulkOp()
y initializeUnorderedBulkOp()
métodos.
Sintaxis:
var bulk = db.collectionName.initializeUnorderedBulkOp();
bulk.insert({document1} );
bulk.insert({document2} );
bulk.insert({documentn} );
bulk.execute();
Ejemplo:
> 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. Recuperar documento de una colección
Para buscar el documento almacenado en una colección, se puede utilizar el método find (). El siguiente comando se utilizará para recuperar todos los documentos de la colección.
find()
El método se puede utilizar para recuperar todos los documentos almacenados en una colección.
Sintaxis: collectionName.find()
Ejemplo:
> 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})
El método se puede usar para recuperar solo los documentos requeridos en función de algunas condiciones de la colección. MongoDB proporciona una lista de operadores de proyección y consulta para recuperar el valor del tipo BSON.
Sintaxis: collectionName.find({ condition })
Ejemplo:
> db.geekFlareCollection.find({ Qty: { $eq: 100 }});
{ "_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"), "code" : "P4", "Qty" : 100, "status" : "Inactive" }
- Para recuperar solo un documento, MongoDB proporciona la
findOne
() método. Da una salida formateada.
Sintaxis: collectionName.findOne()
Ejemplo:
> db.geekFlareCollection.findOne();
{
"_id" : ObjectId("5ed31186b6f2c2bb1edb86ce"),
"code" : "P1",
"Qty" : 200,
"status" : "Inactive"
}
12. Embellecer la salida de recuperación
La find()
El método da una salida desorganizada. MongoDB proporciona pretty()
comandos para obtener la salida formateada.
Sintaxis: collectionName.find().pretty()
Ejemplo:
> db.geekFlareCollection.find({ Qty: { $eq: 100 }}).pretty();
{
"_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"),
"code" : "P4",
"Qty" : 100,
"status" : "Inactive"
}
13. Actualizar documento en una colección
MongoDB proporciona update()
método para establecer nuevos valores para claves existentes en documentos. El comando de actualización brinda detalles de documentos modificados y coincidentes. La sintaxis del comando de actualización es:
Sintaxis: collectionName.update({KeyToUpdate},{Set Command})
Ejemplo:
> 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()
: Para actualizar un solo documento hayupdateOne()
método.updateOne()
Dar el recuento de documentos coincidentes y modificados.
Sintaxis: collectionName.updateOne({SingleKeyToUpdate},{Set Command})
Ejemplo:
> db.geekFlareCollection.updateOne({"product" : "bottles"},{$set : {"Qty": 40}} )
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
<strong>updateMany()</strong>
: Para actualizar varios documentos en alguna condición, MongoDB tieneupdateMany()
método.
Sintaxis: collectionName.updateMany({filter},{Set Command})
Ejemplo:
> db.geekFlareCollection.updateMany( { "Qty" : { $lt: 30 } },{ $set: { "Qty": "Inactive"} } )
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
14. Eliminar documento de una colección
Para eliminar el documento, MongoDB consta de deleteOne()
y deleteMany()
métodos. La sintaxis de los métodos de eliminación es:
<strong>deleteOne({condition}) </strong>
elimina el documento único que cumple los criterios de eliminación.
Sintaxis: collectionName.deleteOne({DeletionCondition})
Ejemplo:
> db.geekFlareCollection.deleteOne({"product" : "bread"})
{ "acknowledged" : true, "deletedCount" : 1 }
<strong>deleteMany() </strong>
elimina todos los documentos que coinciden con los criterios de eliminación. Sin los criterios de eliminacióndeleteMany({condition})
elimina todos los documentos.
Sintaxis: collectionName.deleteMany({DeletionCondition})
Ejemplo:
> db.geekFlareCollection.deleteMany({"product" : "bottles"})
{ "acknowledged" : true, "deletedCount" : 2 }
<strong>remove() </strong>
Existe otro método para eliminar todos los documentos que coinciden con los criterios de eliminación. El método remove () toma dos argumentos, uno es la condición de eliminación y el otro es solo una bandera.
Nota:: El método de eliminación está obsoleto en las próximas versiones.
Sintaxis: collectionName.remove({DeletionCondition},1)
Ejemplo:
> db.geekFlareCollection.remove({"product" : "bottles"})
WriteResult({ "nRemoved" : 1 })
15. Recuperar distinto
La distinct()
El método se utiliza para obtener registros únicos.
- Para obtener registros distintos de un campo.
Sintaxis: collectionName.distinct(field)
Ejemplo:
> db.geekFlareCollection.distinct("product")
[ "Cheese", "Snacks2", "Snacks3", "bread", "ketchup" ]
- Para obtener registros distintos de un campo mientras se especifica la consulta.
Sintaxis: collectionName.distinct(field,query)
Ejemplo:
> db.geekFlareCollection.distinct('product',{"Qty":20})
[ "Snacks3", "bread" ]
16. Cambiar el nombre de la colección
MongoDB proporciona renameCollection ()
método para cambiar el nombre de la colección.
Sintaxis: collectionName.renameCollection(newCollectionName)
Ejemplo:
>db.geekFlareCollection.renameCollection('geekFlareCol')
{ "ok" : 1 }
> show collections
geekFlareCol
Indexing
17. Crear índice en documento
Los índices son una estructura de datos especial que almacena una pequeña parte del conjunto de datos de la colección de forma fácil de recorrer. Los índices admiten el orden ascendente y descendente de los valores de los campos y, por lo tanto, facilitan un mejor rendimiento durante la recuperación.
MongoDB proporciona default_id
índice. Además, MongoDB admite la creación de índices definidos por el usuario. Los índices de MongoDB se definen a nivel de colecciones y brindan soporte en el campo o subcampo de un documento. La sintaxis de crear el índice es:
- Crea un índice en un solo campo.
Sintaxis: collectionName.createIndex({Key:1})
En este, la clave indica el campo en el que se crea el índice y 1 significa orden ascendente. Para crear un índice en orden descendente se puede utilizar -1.
Ejemplo:
> db.geekFlareCollection.createIndex({"product" : 1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
- Cree un índice en varios campos.
Sintaxis: collectionName.createIndex({Key1:1,key2:1…keyn:1})
Ejemplo:
> db.geekFlareCollection.createIndex({"product" : 1,"Qty":-1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
18. Mostrar índice en el documento
MongoDB proporciona getIndexes()
método para enumerar todos los índices creados en un documento.
Sintaxis: collectionName.getIndexes()
Ejemplo:
> db.geekFlareCollection.getIndexes()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "geekFlareCollection.geekFlareCollection"
}
]
19. Eliminar índice del documento
dropIndex()
El método se usa para eliminar el índice único y el método dropIndexes () se usa para eliminar múltiples índices.
- Quitar índice único
Sintaxis: collectionName.dropIndex({key})
Ejemplo:
> db.geekFlareCollection.dropIndex({"product" : 1})
{ "nIndexesWas" : 3, "ok" : 1 }
- Eliminar varios índices.
Sintaxis: collectionName.dropIndexes({key1,key2…,keyN})
Ejemplo:
> db.geekFlareCollection.dropIndexes({"product" : 1,"Qty":-1})
{ "nIndexesWas" : 3, "ok" : 1 }
Retrieval related
20. Limitar la recuperación de documentos
limit()
El método ayuda a limitar el número de documentos devueltos. El método limit () acepta argumentos numéricos.
Sintaxis: collectionName.find().limit(number)
Ejemplo:
> db.geekFlareCollection.find().limit(2)
{ "_id" : ObjectId("5ed3c9e7b6f2c2bb1edb8702"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5ed3c9e7b6f2c2bb1edb8703"), "product" : "bread", "Qty" : 20 }
21. Omitir la recuperación de documentos
Soporta MongoDB skip()
método. Este método omite el número requerido de documentos. Acepta un argumento numérico.
Sintaxis: collectionName.find().skip(number)
Ejemplo:
> db.geekFlareCollection.find().skip(2)
{ "_id" : 3, "product" : "yogurt", "Qty" : 30 }
> db.geekFlareCollection.find().skip(3)
22. Clasificar recuperación de documentos
MongoDB sort()
Este método clasifica los documentos de salida en orden ascendente o descendente. Este método acepta el nombre de las claves con el número para especificar el orden de clasificación. 1 se usa para el orden ascendente, mientras que -1 se usa para especificar el orden descendente.
Sintaxis: collectionName.find().sort({key:1})
Ejemplo:
> 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. Validación de documentos
Los validadores ayudan a restringir el tipo de datos que se insertan en los documentos. Los validadores se definen en la recopilación. Se requiere la creación de un validador para usar la palabra clave validador y opcional nivel de validación y acción de validación para especificar el modo de validación. La validación del documento no restringe la inserción del nuevo campo en el documento.
Sintaxis: createCollection(“collectionName”,{validator:{ fields condition }})
Ejemplo:
> 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. Validadores de esquema en una nueva colección
Palabra clave adicional $ jsonSchema para cada año fiscal junto con la propiedades adicionales valor como Falso es necesario para poner restricción a nivel de esquema. Evita que se agreguen nuevos campos en el documento.
Sintaxis: createCollection(“collectionName”,{validator: { $jsonSchema { schema condition } }})
Ejemplo:
> 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. Actualizar o crear validadores de esquema en una colección existente
Se puede crear un validador en una colección existente usando collMod
Sintaxis: runCommand({collMod:”collectionName”,validator:{schema condition}})
Ejemplo:
> 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. Eliminar validadores de esquema en una colección existente
Para eliminar validadores de esquema, es necesario configurar <strong>validationLevel</strong>
como apagado.
Sintaxis: runCommand({collMod:”collectionName”,validator:{ },validationLevel:off})
Ejemplo:
> db.runCommand({
collMod:"Login",
validator:{},
validationLevel:"off"
})
{ "ok" : 1 }
>
> db.Login.insert({"email":"abc"})
WriteResult({ "nInserted" : 1 })
27. Verificar validadores en una colección existente
Para verificar si la colección existente tiene validadores de esquema que se ejecutan debajo del comando. Sin especificar el nombre de la colección db.getCollectionInfos()
El método proporciona detalles de validadores en todas las colecciones que residen dentro de una base de datos.
Sintaxis: getCollectionInfos({name : “collectionName”})
Ejemplo:
> db.getCollectionInfos({name: "Login"})
[
{
"name" : "Login",
"type" : "collection",
"options" : {
"validator" : {
"email" : {
"$regex" : /@flares\.com$/
}
}
},
"info" : {
"readOnly" : false,
"uuid" : UUID("646674f6-4b06-466d-93b0-393b5f5cb4ff")
},
"idIndex" : {
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "geekFlareDB.Login"
}
}
]
Cursors related
28. Cursor en MongoDB
El cursor es un puntero para iterar sobre el conjunto de resultados. Usos de MongoDB <strong>hasNext()</strong>
y <strong>forEach()</strong>
método de iteración. Una lista de métodos de cursor se ha proporcionado.
Ejemplos:
> 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
Utility
29. Realización de una copia de seguridad de la base de datos
mongodump
La utilidad se utiliza para exportar el contenido de la base de datos MongoDB como copia de seguridad. Este comando se ejecuta desde la consola del sistema y no desde mongo shell. Generará una copia de seguridad binaria junto con la información de metadatos.
Sintaxis:
mongodump --db dbName --out outFile --host "IP:PORT" --username <user> --password <pass>
Ejemplo:
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. Restaurar la base de datos desde la copia de seguridad
La utilidad <strong>mongorestore</strong>
se utiliza para restaurar datos binarios generados por mongodump
.
Sintaxis: mongorestore --db newDB "pathOfOldBackup"
Ejemplo:
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. Exportación de colecciones
Para exportar el contenido de la colección a un archivo (JSON o CSV) mongoexport
Se ha proporcionado utilidad. Para ejecutar este comando, use el terminal del sistema.
- Exporta una sola colección a un archivo.
Sintaxis: mongoexport --db dbName --collection collectionName --out outputFile
Ejemplo:
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
- Exporta un campo específico de la colección a un archivo.
Sintaxis: mongoexport --db dbName --collection collectionName --out outputFile --fields fieldname
Ejemplo:
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. Importación de colecciones
Para importar datos de un archivo (CSV o JSON) mongoimport
Se puede utilizar la herramienta de línea de comandos.
Sintaxis: 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.
Replica related
La replicación es diferente a la fragmentación, consulte esta guía para implementar fragmentación.
33. Replicación de MongoDB
La replicación es el proceso para sincronizar datos en varios servidores. Evita la pérdida de datos debido a un mal funcionamiento del hardware o software. MongoDB logra la replicación utilizando conjuntos de réplicas. El conjunto de réplicas consta de conjuntos de datos de Mongo primarios y secundarios en el clúster.
El conjunto de datos primarios acepta todas las operaciones de escritura y las lecturas del conjunto de datos secundarios del primario. Se requieren 3 conjuntos de datos como mínimo en el conjunto de réplicas de Mongo. Se requiere el siguiente proceso para configurar un conjunto de réplicas:
- Comienzo
mongod
servidor conreplset
opción en un mínimo de 3 nodos.
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
- Inicialice el conjunto 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. Compruebe el estado de la replicación
Ejecute el siguiente comando desde el nodo de réplica principal para obtener información completa del conjunto de réplicas.
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. Agregar una nueva instancia de MongoDB a un conjunto de réplicas
Inicie el cliente principal de MongoDB y ejecute el siguiente comando
Sintaxis: rs.add(“hostname:port”)
Ejemplo:
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. Elimina la instancia de MongoDB existente del conjunto de réplicas
El siguiente comando eliminará el host secundario requerido del conjunto de réplicas.
Sintaxis: rs.remove("localhost:27017")
Ejemplo:
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. Establecer como primario como conjunto de réplicas secundario
MongoDB proporciona un comando para indicar a la réplica principal que se convierta en un conjunto de réplicas secundario.
Sintaxis: rs.stepDown( stepDownSecs , secondaryCatchupSecs )
Ejemplo:
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. Compruebe el retraso de la réplica entre primaria y secundaria
El siguiente comando se utilizará para verificar el retraso de replicación entre todos los conjuntos de réplicas del primario.
Sintaxis: rs.printSlaveReplicationInfo()
Ejemplo:
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. Transacciones en MongoDB
MongoDB admite propiedades ACID para transacciones en documentos.
Para iniciar una transacción, se requiere una sesión para comenzar y se requiere un compromiso para guardar los cambios en la base de datos. Las transacciones se admiten en juegos de réplicas o mangos. Una vez que la sesión se comprometió con éxito, las operaciones realizadas dentro de la sesión serán visibles en el exterior.
- Iniciar sesión
Sintaxis: session =
db.getMongo().startSession()
- Iniciar transacción,
Sintaxis: session.startTransaction()
- Confirmar transacción
Sintaxis: session.commitTransaction()
Ejemplo:
Creemos una sesión, iniciemos la transacción, realicemos alguna inserción / actualización y luego confirmemos la transacción.
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. Conflicto de transacciones de un solo documento
Si dos transacciones intentaron actualizar el mismo documento, MongoDB arroja un error de conflicto de escritura.
session1.startTransaction()
session2.startTransaction()
Realice alguna inserción / actualización en Session1 seguida de en Session2. Ahora observe el error en el siguiente ejemplo
Ejemplo:
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. Transacciones de varios documentos
MongoDB admite transacciones de varios documentos en una sola sesión.
- db.getMongo ().startTransaction ()
Realice alguna inserción / actualización en varios documentos
- de preguntas y respuestas.commitTransaction ()
Ejemplo:
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. Perfilado en MongoDB
La creación de perfiles ayuda a registrar consultas lentas en el system.profile
colección. Nivel de perfilador y la frecuencia de muestreo define el porcentaje de consultas que se iniciarán sesión system.profile
colección.
- Establecer / obtener nivel de perfil
Sintaxis:
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
- Obtener estado de perfil
Sintaxis: db.getProfilingStatus ()
> db.getProfilingStatus()
{ "was" : 2, "slowms" : 1, "sampleRate" : 1 }
- Para habilitar la generación de perfiles en el nivel de instancia de MongoDB, inicie la instancia con la información del generador de perfiles o agregue los detalles del generador de perfiles en el archivo de configuración.
Sintaxis:
mongod --profile <Level> --slowms <time> --slowOpSampleRate <%Logging>
Ejemplo:
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()
El método devuelve estadísticas y proporciona información para seleccionar un plan ganador y ejecutarlo hasta su finalización. Devuelve resultados según el plan de verbosidad.
Sintaxis: collectionName.explain(“verbosityName”)
Para ejecutar el método / comandoexplica (), creemos un verbosidad y luego ejecute el método explica (), eche un vistazo al siguiente ejemplo, donde se han ejecutado estos pasos.
Ejemplo:
> 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
}
>
Access control related
44. Control de acceso en MongoDB
Las funciones de control de acceso permiten el acceso de autenticación a los usuarios existentes. Para el control de acceso, la base de datos habilitada para garantizar la creación de un rol de administrador de usuario en la base de datos de administración.
- Conecte la base de datos sin autenticación.
- Cambiar a la base de datos
use admin
- Crear usuario como a continuación
db.createUser( {user: “UserAdmin”, pwd: “password” ,role: [adminRole])
Ejemplo:
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"
]
}
- Reanudar
mongod
ejemplo - Acceda nuevamente con el usuario y la contraseña creados.
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. Recuperar y eliminar usuario de control de acceso
El siguiente comando se puede usar para verificar la información del usuario y eliminarla.
db.getUser("AdminUser")
db.dropUser("AdminUser")
Ejemplo:
> 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. Otorgar funciones definidas por el usuario
MongoDB proporciona db.createRole()
método para especificar los privilegios de un usuario y una serie de roles heredados.
- Conecte la instancia de MongoDB con el usuario administrador.
- Ejecute el siguiente comando para generar un nuevo rol.
Sintaxis:
db.createRole({role:”roleName”,privileges:[{privilegeName}],roles:[InheritedArray]})
Ejemplo:
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. Revocar funciones definidas por el usuario
Para modificar los roles existentes, use el siguiente comando.
Sintaxis: db.revokeRolesFromUser( userName, [{ "role" : roleName , db:dbName} ] )
Ejemplo:
> 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. Conectividad de MongoDB con Python
Se requiere el paquete pymongo para conectar MongoDB desde la consola de 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'}
>>>
¿Qué es lo siguiente?
Mira esta lista de Clientes NoSQL para administrar MongoDB y otras bases de datos NoSQL. Si su trabajo implica trabajar con frecuencia en MongoDB, es posible que desee obtener más información de este Curso Udemy.