48 comandos y consultas de MongoDB para conocer como desarrollador y administrador de bases de datos

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.

Introducción rápida

En esta nueva era de tecnología inteligente, los datos se están generandoated en gran volumen y cada dato es equally importante para growindustrias de construcción. Los usuarios generan datos estructurados, semiestructurados y no estructurados en una cantidad ilimitada. Compilación de datos estructuradosrises almacenar datos en tablas y rows mientras que los datos no estructurados consisten en imágenes, vídeos y clips de voz. Debido al creciente volumen de datos estructurados y no estructurados, la necesidad de Base de datos NoSQL entra en la imagen.

Proporciona a los desarrolladores facilidad para diseñar esquemas y escalabilidad. platformulario a los administradores de bases de datos, proporciona una forma segura y rápida plat.

¿Qué es MongoDB?

MongoDB es una herramienta transversal y orientada a documentos.platForm y base de datos NoSQL de código abierto que se utiliza para almacenar datos semiestructurados escritos en C++. En lugar de mesas y rows, 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 que se utilizan con frecuencia.

Vamos a ponerlo en marcha.

Comandos básicos

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 la 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 related parámetros 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. create Nueva base de datos o cambio a base de datos existente

Este simple comando ayuda a crearate una nueva base de datos si no existe o ayuda para 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 soltar. Otrowise, 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. create Colección

Las colecciones son similares a las tablas en RDBMS.

Create un comando de colección consta de dos parámetros. La colección consta de zero 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: vamos a crearate una colección limitada, inserte un registro y recupérelo

> 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.ated 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

Operaciones CRUD related

10. Inserte el documento en la colección

En MongoDB, el documento es similar a una tupla en RDBMS.

para crearate un documento, el insert() Se utiliza el método. El método insert() creaates uno o varios documentos de la colección existente. También creates colección si no está presente en la base de datos. En MongoDB, el documento no tiene esquema, lo que significa que no hay restricciones para insertar cualquier cantidad 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. Actualizarate Documento en una colección

MongoDB proporciona update() Método para establecer nuevos valores para claves existentes en documentos. Actualizarate El comando proporciona detalles de los documentos modificados y coincidentes. Sintaxis de update comando 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 actualizarate un solo documento hay updateOne() 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 actualizarate múltiples documentos en alguna condición que MongoDB tiene updateMany() 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ón deleteMany({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á en desusoated en 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

Indexación

17. create Índice del documento

Los índices son una estructura de datos especial que almacena una pequeña parte del conjunto de datos de la colección en un formato fácil de recorrer. Los índices admiten el orden ascendente y descendente de los valores de los campos y, por lo tanto, facilitanate mejor rendimiento durante la recuperación.

MongoDB proporciona default_id índice. Además, MongoDB soporta la creation 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. Sintaxis de create el índice es:

• Create un índice en un solo campo.

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

En esto, el indicador claveates el campo en el que se crea el índiceated y 1 significan orden ascendente. para crearate Se puede utilizar un índice en orden descendente -1.

Ejemplo:

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

• Create un índice en múltiples 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 created 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 }

Recuperación 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 }

Validación 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 el momento de la recopilación. Validador creation es necesario para utilizar 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 poner restricciones a nivel de esquema. es prevpermite agregar nuevos campos al 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. Actualizarate o create Validadores de esquemas en una colección existente

Un validador puede ser created en la 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"
                }
        }
]

Cursores related

28. Cursor en MongoDB

El cursor es un puntero a iter.ate 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 

Utilidad

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áate copia de seguridad binaria junto con 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 el gene de datos binariosated 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.

Réplica 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 la process a synccronizar datos en múltiples servidores. es prevEsto provoca 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 Mongo primarios y secundarios en el clúster.

El conjunto de datos primario acepta todas las operaciones de escritura y lecturas del conjunto de datos secundario desde el primario. Se requieren un mínimo de 3 conjuntos de datos en el conjunto de réplicas de Mongo. Abajo process Se requiere para configurar un conjunto de réplicas:

• Comienzo mongod servidor con replset 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>

Transacciones 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:

vamos a crearate una sesión, iniciar la transacción, realizar alguna inserción/actualizaciónate y luego confirmar 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 actualizarseate el mismo documento, MongoDB throws escribir error de conflicto.

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

Realizar alguna inserción/actualizaciónate en la Sesión 1 seguida de la Sesión 2. 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 ()

Realizar alguna inserción/actualizaciónate en múltiples 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. Profiling en MongoDB

Profiling ayuda a registrar consultas lentas en el system.profile colección. Profinivel de lectura y muestra rate definir el porcentaje de consultas a iniciar sesión system.profile colección.

• Colocar tomar Profinivel de maruca

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

• Get Profiestado de maruca

Sintaxis: db.getProfiestadoling()

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

• Para permitir profiling en el nivel de instancia de MongoDB, inicie la instancia con profiler información o agregar profiDetalles del controlador 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/comando explicó(), creemosate a 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
}
>

Control de acceso 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 habilitado DB para garantizar la creaciónate un rol de administrador de usuario en la base de datos de administrador.

• Conecte la base de datos sin autenticación.
• Cambiar a la base de datos

use admin

• Create 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
• Accede nuevamente con created usuario y contraseña.

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 generarate 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. Revoke Roles definidos 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.