MongoDB: descripción general

MongoDB es una base de datos multiplataforma orientada a documentos que proporciona

alto rendimiento, alta disponibilidad y fácil escalabilidad. MongoDB trabaja en el concepto
de colección y documento.

Base de datos
La base de datos es un contenedor físico para colecciones. Cada base de datos obtiene su
propio conjunto de archivos en el sistema de archivos. Un solo servidor MongoDB
normalmente tiene varias bases de datos.

Colección
La colección es un grupo de documentos MongoDB. Es el equivalente a una tabla
RDBMS. Existe una colección dentro de una sola base de datos. Las colecciones no
imponen un esquema. Los documentos de una colección pueden tener diferentes campos.
Normalmente, todos los documentos de una colección tienen un propósito similar o
relacionado.

Documento
Un documento es un conjunto de pares clave-valor. Los documentos tienen un esquema
dinámico. El esquema dinámico significa que los documentos de la misma colección no
necesitan tener el mismo conjunto de campos o estructura, y los campos comunes en los
documentos de una colección pueden contener diferentes tipos de datos.
La siguiente tabla muestra la relación de la terminología RDBMS con MongoDB.

RDBMS MongoDB

Base de datos Base de datos

Tabla Colección

Tupla / Fila Documento

columna Campo

Unión de tabla Documentos incrustados

Clave primaria Clave principal (clave predeterminada _id proporcionada por MongoDB)
 Cliente y servidor de base de datos

mysqld / Oracle mongod

mysql / sqlplus mongo

Documento de muestra
El siguiente ejemplo muestra la estructura del documento de un sitio de blog, que es
simplemente un par clave-valor separado por comas.

{
_id: ObjectId(7df78ad8902c)
title: 'MongoDB Overview',
description: 'MongoDB is no sql database',
by: 'tutorials point',
url: '[Link]
tags: ['mongodb', 'database', 'NoSQL'],
likes: 100,
comments: [
{
user:'user1',
message: 'My first comment',
dateCreated: new Date(2011,1,20,2,15),
like: 0
},
{
user:'user2',
message: 'My second comments',
dateCreated: new Date(2011,1,25,7,45),
like: 5
}
]
}

_id es un número hexadecimal de 12 bytes que asegura la singularidad de cada

documento. Puede proporcionar _id al insertar el documento. Si no lo proporciona,
MongoDB proporciona una identificación única para cada documento. Estos 12 bytes, los
primeros 4 bytes para la marca de tiempo actual, los siguientes 3 bytes para la
identificación de la máquina, los siguientes 2 bytes para la identificación del proceso del
servidor MongoDB y los 3 bytes restantes son un valor incremental simple.

MongoDB - Ventajas
Cualquier base de datos relacional tiene un diseño de esquema típico que muestra el
número de tablas y la relación entre estas tablas. Mientras que en MongoDB, no existe el
concepto de relación.

Ventajas de MongoDB sobre RDBMS

• Schema less- MongoDB es una base de datos de documentos en la que una
colección contiene diferentes documentos. El número de campos, el contenido y el
tamaño del documento pueden diferir de un documento a otro.
• La estructura de un solo objeto es clara.
• Sin combinaciones complejas.
• Capacidad de consulta profunda. MongoDB admite consultas dinámicas en
documentos utilizando un lenguaje de consulta basado en documentos que es casi
tan poderoso como SQL.
• Tuning.
• Ease of scale-out - MongoDB es fácil de escalar.
• No se necesita conversión / mapeo de objetos de aplicación a objetos de base de
datos.
• Utiliza memoria interna para almacenar el conjunto de trabajo (en ventana), lo que
permite un acceso más rápido a los datos.

¿Por qué utilizar MongoDB?

• Document Oriented Storage - Los datos se almacenan en forma de documentos
de estilo JSON.
• Índice de cualquier atributo
• Replicación y alta disponibilidad
• Auto-Sharding
• Consultas enriquecidas
• Actualizaciones rápidas en el lugar
• Soporte profesional de MongoDB

¿Dónde usar MongoDB?

• Big Data
 • Entrega y administración de contenido
• Infraestructura móvil y social
• Gestión de datos de usuario
• Centro de datos

MongoDB - Modelado de datos

Los datos en MongoDB tienen un esquema flexible. Documentos en la misma colección.
No es necesario que tengan el mismo conjunto de campos o estructura Los campos
comunes en los documentos de una colección pueden contener diferentes tipos de datos.

Diseño de modelos de datos

MongoDB proporciona dos tipos de modelos de datos: - Modelo de datos integrado y
Modelo de datos normalizado. Según el requisito, puede utilizar cualquiera de los modelos
mientras prepara su documento.

Modelo de datos integrado

En este modelo, puede tener (incrustar) todos los datos relacionados en un solo
documento, también se conoce como modelo de datos desnormalizados.
Por ejemplo, suponga que estamos obteniendo los detalles de los empleados en tres
documentos diferentes, a saber, Detalles personales, Contacto y Dirección, puede
incrustar los tres documentos en uno solo como se muestra a continuación:

{
_id: ,
Emp_ID: "10025AE336"
Personal_details:{
First_Name: "Radhika",
Last_Name: "Sharma",
Date_Of_Birth: "1995-09-26"
},
Contact: {
e-mail: "radhika_sharma.123@[Link]",
phone: "9848022338"
},
Address: {
city: "Hyderabad",
Area: "Madapur",
State: "Telangana"
}
}

Modelo de datos normalizado

En este modelo, puede consultar los subdocumentos del documento original, utilizando
referencias. Por ejemplo, puede volver a escribir el documento anterior en el modelo
normalizado como:
Employee:

{
_id: <ObjectId101>,
Emp_ID: "10025AE336"
}

Personal_details:

{
_id: <ObjectId102>,
empDocID: " ObjectId101",
First_Name: "Radhika",
Last_Name: "Sharma",
Date_Of_Birth: "1995-09-26"
}

Contact:

{
_id: <ObjectId103>,
empDocID: " ObjectId101",
e-mail: "radhika_sharma.123@[Link]",
phone: "9848022338"
}

Address:

{
_id: <ObjectId104>,
empDocID: " ObjectId101",
city: "Hyderabad",
Area: "Madapur",
State: "Telangana"
}
Consideraciones al diseñar Schema en
MongoDB
• Diseñe su esquema de acuerdo con los requisitos del usuario.
• Combine objetos en un documento si los usará juntos. De lo contrario, sepárelos
(pero asegúrese de que no sea necesario unirlos).
• Duplique los datos (pero limitado) porque el espacio en disco es barato en
comparación con el tiempo de cálculo.
• Realice uniones mientras escribe, no en lectura.
• Optimice su esquema para los casos de uso más frecuentes.
• Realice una agregación compleja en el esquema.

Ejemplo
Supongamos que un cliente necesita un diseño de base de datos para su blog / sitio web y
ve las diferencias entre RDBMS y el diseño de esquema de MongoDB. El sitio web tiene
los siguientes requisitos.
• Cada publicación tiene un título, una descripción y una URL únicos.
• Cada publicación puede tener una o más etiquetas.
• Cada publicación tiene el nombre de su editor y el número total de Me gusta.
• Cada publicación tiene comentarios proporcionados por los usuarios junto con su
nombre, mensaje, tiempo de datos y me gusta.
• En cada publicación, puede haber cero o más comentarios.
En el esquema RDBMS, el diseño de los requisitos anteriores tendrá un mínimo de tres
tablas.

Mientras esté en el esquema de MongoDB, el diseño tendrá una publicación de colección y

la siguiente estructura:

{
_id: POST_ID
title: TITLE_OF_POST,
 description: POST_DESCRIPTION,
by: POST_BY,
url: URL_OF_POST,
tags: [TAG1, TAG2, TAG3],
likes: TOTAL_LIKES,
comments: [
{
user:'COMMENT_BY',
message: TEXT,
dateCreated: DATE_TIME,
like: LIKES
},
{
user:'COMMENT_BY',
message: TEXT,
dateCreated: DATE_TIME,
like: LIKES
}
]
}

Entonces, mientras muestra los datos, en RDBMS debe unir tres tablas y en MongoDB, los
datos se mostrarán solo de una colección.

MongoDB - Crear base de datos

En este capítulo, veremos cómo crear una base de datos en MongoDB.

El comando de uso
MongoDB use DATABASE_NAMEse utiliza para crear la base de datos. El comando
creará una nueva base de datos si no existe; de lo contrario, devolverá la base de datos
existente.

Sintaxis
Sintaxis básica de use DATABASE declaración es la siguiente:

use DATABASE_NAME
Ejemplo
Si desea utilizar una base de datos con nombre <mydb>, luego use
DATABASE declaración sería la siguiente:

>use mydb
switched to db mydb

Para verificar su base de datos actualmente seleccionada, use el comando db

>db
mydb

Si desea verificar su lista de bases de datos, use el comando show dbs.

>show dbs
local 0.78125GB
test 0.23012GB

Su base de datos creada (mydb) no está presente en la lista. Para mostrar la base de
datos, debe insertar al menos un documento en ella.

>[Link]({"name":"tutorials point"})
>show dbs
local 0.78125GB
mydb 0.23012GB
test 0.23012GB

En MongoDB, la base de datos predeterminada es prueba. Si no creó ninguna base de

datos, las colecciones se almacenarán en la base de datos de prueba.

MongoDB - Eliminar base de datos

En este capítulo, veremos cómo soltar una base de datos usando el comando MongoDB.

El método dropDatabase ()
MongoDB [Link]() El comando se usa para eliminar una base de datos
existente.

Sintaxis
Sintaxis básica de dropDatabase() El comando es el siguiente:

[Link]()
Esto eliminará la base de datos seleccionada. Si no ha seleccionado ninguna base de
datos, eliminará la base de datos de 'prueba' predeterminada.

Ejemplo
Primero, verifique la lista de bases de datos disponibles usando el comando, show dbs.

>show dbs
local 0.78125GB
mydb 0.23012GB
test 0.23012GB
>

Si desea eliminar una nueva base de datos <mydb>, luego dropDatabase() comando
sería el siguiente:

>use mydb
switched to db mydb
>[Link]()
>{ "dropped" : "mydb", "ok" : 1 }
>

Ahora verifique la lista de bases de datos.

>show dbs
local 0.78125GB
test 0.23012GB
>

MongoDB - Crear colección

En este capítulo, veremos cómo crear una colección usando MongoDB.

El método createCollection ()
MongoDB [Link](name, options) se utiliza para crear una colección.

Sintaxis
Sintaxis básica de createCollection() El comando es el siguiente:

[Link](name, options)

En el comando, name es el nombre de la colección que se creará. Options es un

documento y se utiliza para especificar la configuración de la colección.
 Parámetro Tipo Descripción

Nombre Cuerda Nombre de la colección a crear

Opciones Documento (Opcional) Especifique opciones sobre el tamaño de la memoria

y la indexación

El parámetro de opciones es opcional, por lo que debe especificar solo el nombre de la

colección. A continuación se muestra la lista de opciones que puede utilizar:

Campo Tipo Descripción

tapado Booleano (Opcional) Si es verdadero, habilita una colección limitada. La

colección limitada es una colección de tamaño fijo que
sobrescribe automáticamente sus entradas más antiguas cuando
alcanza su tamaño má[Link] you specify true, you need to
specify size parameter also.

autoIndexId Booleano (Opcional) Si es verdadero, crea automáticamente un índice en el

campo _id. El valor predeterminado es falso.

Talla número (Opcional) Especifica un tamaño máximo en bytes para una

colección con límite. If capped is true, then you need to specify
this field also.

max número (Opcional) Especifica el número máximo de documentos

permitidos en la colección limitada.

Al insertar el documento, MongoDB primero verifica el campo de tamaño de la colección

con límite, luego verifica el campo máximo.

Ejemplos
Sintaxis básica de createCollection() El método sin opciones es el siguiente:

>use test
switched to db test
>[Link]("mycollection")
{ "ok" : 1 }
>
Puede verificar la colección creada usando el comando show collections.

>show collections
mycollection
[Link]

El siguiente ejemplo muestra la sintaxis de createCollection() método con pocas opciones

importantes -

> [Link]("mycol", { capped : true, autoIndexID : true, size : 61

42800, max : 10000 } ){
"ok" : 0,
"errmsg" : "BSON field '[Link]' is an unknown field.",
"code" : 40415,
"codeName" : "Location40415"
}
>

En MongoDB, no es necesario crear una colección. MongoDB crea una colección

automáticamente cuando inserta algún documento.

>[Link]({"name" : "tutorialspoint"}),
WriteResult({ "nInserted" : 1 })
>show collections
mycol
mycollection
[Link]
tutorialspoint
>

MongoDB - Colección Drop

En este capítulo, veremos cómo eliminar una colección usando MongoDB.

El método drop ()
MongoDB's [Link]() se utiliza para eliminar una colección de la base de
datos.

Sintaxis
Sintaxis básica de drop() El comando es el siguiente:
db.COLLECTION_NAME.drop()

Ejemplo
Primero, verifique las colecciones disponibles en su base de datos mydb.

>use mydb
switched to db mydb
>show collections
mycol
mycollection
[Link]
tutorialspoint
>

Ahora suelta la colección con el nombre mycollection.

>[Link]()
true
>

Vuelva a comprobar la lista de colecciones en la base de datos.

>show collections
mycol
[Link]
tutorialspoint
>

El método drop () devolverá verdadero, si la colección seleccionada se elimina con éxito,

de lo contrario, devolverá falso.

MongoDB - Tipos de datos

MongoDB admite muchos tipos de datos. Algunos de ellos son ...
• String- Este es el tipo de datos más utilizado para almacenar los datos. La cadena
en MongoDB debe ser válida para UTF-8.
• Integer- Este tipo se utiliza para almacenar un valor numérico. El número entero
puede ser de 32 bits o 64 bits dependiendo de su servidor.
• Boolean - Este tipo se utiliza para almacenar un valor booleano (verdadero / falso).
• Double - Este tipo se utiliza para almacenar valores de coma flotante.
 • Min/ Max keys - Este tipo se utiliza para comparar un valor con los elementos
BSON más bajos y más altos.
• Arrays - Este tipo se utiliza para almacenar matrices o listas o valores múltiples en
una clave.
• Timestamp- marca de tiempo. Esto puede ser útil para grabar cuando se ha
modificado o agregado un documento.
• Object - Este tipo de datos se utiliza para documentos incrustados.
• Null - Este tipo se utiliza para almacenar un valor nulo.
• Symbol- Este tipo de datos se utiliza de forma idéntica a una cadena; sin embargo,
generalmente está reservado para idiomas que usan un tipo de símbolo específico.
• Date - Este tipo de datos se utiliza para almacenar la fecha u hora actual en
formato de hora UNIX. Puede especificar su propia fecha y hora creando un objeto
de Fecha y pasando día, mes y año en él.
• Object ID - Este tipo de datos se utiliza para almacenar el ID del documento.
• Binary data - Este tipo de datos se utiliza para almacenar datos binarios.
• Code - Este tipo de datos se utiliza para almacenar código JavaScript en el
documento.
• Regular expression - Este tipo de datos se utiliza para almacenar expresiones
regulares.

MongoDB - Insertar documento

En este capítulo, aprenderemos cómo insertar documentos en la colección MongoDB.

El método insert ()
Para insertar datos en la colección de MongoDB, debe usar
MongoDB's insert() o save() método.

Sintaxis
La sintaxis básica de insert() El comando es el siguiente:

>db.COLLECTION_NAME.insert(document)

Ejemplo
> [Link]({
... _id : ObjectId("507f191e810c19729de860ea"),
... title: "MongoDB Overview",
... description: "MongoDB is no sql database",
... by: "tutorials point",
... url: "[Link]
... tags: ['mongodb', 'database', 'NoSQL'],
... likes: 100
... })
WriteResult({ "nInserted" : 1 })
>

aquí mycol es el nombre de nuestra colección, como se creó en el capítulo anterior. Si la

colección no existe en la base de datos, MongoDB creará esta colección y luego insertará
un documento en ella.
En el documento insertado, si no especificamos el parámetro _id, MongoDB asigna un
Object Id único para este documento.
_id es un número hexadecimal de 12 bytes único para cada documento de una colección.
12 bytes se dividen de la siguiente manera:

_id: ObjectId(4 bytes timestamp, 3 bytes machine id, 2 bytes process id, 3 by
tes incrementer)

También puede pasar una matriz de documentos al método insert () como se muestra a
continuación :.

> [Link]("post")
> [Link]([
{
title: "MongoDB Overview",
description: "MongoDB is no SQL database",
by: "tutorials point",
url: "[Link]
tags: ["mongodb", "database", "NoSQL"],
likes: 100
},
{
title: "NoSQL Database",
description: "NoSQL database doesn't have tables",
by: "tutorials point",
url: "[Link]
tags: ["mongodb", "database", "NoSQL"],
likes: 20,
comments: [
{
user:"user1",
message: "My first comment",
 dateCreated: new Date(2013,11,10,2,35),
like: 0
}
]
}
])
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 2,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
>

Para insertar el documento puede utilizar [Link](document)además. Si no

especifica_id en el documento entonces save() El método funcionará igual
que insert()método. Si especifica _id, reemplazará los datos completos del documento que
contiene _id como se especifica en el método save ().

El método insertOne ()
Si necesita insertar solo un documento en una colección, puede utilizar este método.

Sintaxis
La sintaxis básica del comando insert () es la siguiente:

>db.COLLECTION_NAME.insertOne(document)

Ejemplo
El siguiente ejemplo crea una nueva colección llamada empDetails e inserta un documento
usando el método insertOne ().

> [Link]("empDetails")
{ "ok" : 1 }
> [Link](
{
First_Name: "Radhika",
 Last_Name: "Sharma",
Date_Of_Birth: "1995-09-26",
e_mail: "radhika_sharma.123@[Link]",
phone: "9848022338"
})
{
"acknowledged" : true,
"insertedId" : ObjectId("5dd62b4070fb13eec3963bea")
}
>

El método insertMany ()
Puede insertar varios documentos utilizando el método insertMany (). Para este método,
debe pasar una serie de documentos.

Ejemplo
El siguiente ejemplo inserta tres documentos diferentes en la colección empDetails usando
el método insertMany ().

> [Link](
[
{
First_Name: "Radhika",
Last_Name: "Sharma",
Date_Of_Birth: "1995-09-26",
e_mail: "radhika_sharma.123@[Link]",
phone: "9000012345"
},
{
First_Name: "Rachel",
Last_Name: "Christopher",
Date_Of_Birth: "1990-02-16",
e_mail: "Rachel_Christopher.123@[Link]",
phone: "9000054321"
},
{
First_Name: "Fathima",
Last_Name: "Sheik",
 Date_Of_Birth: "1990-02-16",
e_mail: "Fathima_Sheik.123@[Link]",
phone: "9000054321"
}
]
)
{
"acknowledged" : true,
"insertedIds" : [
ObjectId("5dd631f270fb13eec3963bed"),
ObjectId("5dd631f270fb13eec3963bee"),
ObjectId("5dd631f270fb13eec3963bef")
]
}
>

MongoDB - Documento de consulta

En este capítulo, aprenderemos cómo consultar documentos de la colección MongoDB.

El método find ()
Para consultar datos de la colección de MongoDB, debe usar MongoDB's find() método.

Sintaxis
La sintaxis básica de find() El método es el siguiente:

>db.COLLECTION_NAME.find()

find() El método mostrará todos los documentos de forma no estructurada.

Ejemplo
Supongamos que hemos creado una colección llamada mycol como:

> use sampleDB

switched to db sampleDB
> [Link]("mycol")
{ "ok" : 1 }
>
E insertó 3 documentos en él usando el método insert () como se muestra a continuación:

> [Link]([
{
title: "MongoDB Overview",
description: "MongoDB is no SQL database",
by: "tutorials point",
url: "[Link]
tags: ["mongodb", "database", "NoSQL"],
likes: 100
},
{
title: "NoSQL Database",
description: "NoSQL database doesn't have tables",
by: "tutorials point",
url: "[Link]
tags: ["mongodb", "database", "NoSQL"],
likes: 20,
comments: [
{
user:"user1",
message: "My first comment",
dateCreated: new Date(2013,11,10,2,35),
like: 0
}
]
}
])

El siguiente método recupera todos los documentos de la colección:

> [Link]()
{ "_id" : ObjectId("5dd4e2cc0821d3b44607534c"), "title" : "MongoDB Overview",
"description" : "MongoDB is no SQL database", "by" : "tutorials point", "url"
: "[Link] "tags" : [ "mongodb", "database", "NoSQL"
], "likes" : 100 }
{ "_id" : ObjectId("5dd4e2cc0821d3b44607534d"), "title" : "NoSQL Database", "
description" : "NoSQL database doesn't have tables", "by" : "tutorials point"
, "url" : "[Link] "tags" : [ "mongodb", "database",
"NoSQL" ], "likes" : 20, "comments" : [ { "user" : "user1", "message" : "My f
irst comment", "dateCreated" : ISODate("2013-12-09T21:05:00Z"), "like" : 0 }
] }
>

El método pretty ()
Para mostrar los resultados de forma formateada, puede utilizar el método pretty ().

Sintaxis
>db.COLLECTION_NAME.find().pretty()

Ejemplo
El siguiente ejemplo recupera todos los documentos de la colección denominada mycol y
los organiza en un formato fácil de leer.

> [Link]().pretty()
{
"_id" : ObjectId("5dd4e2cc0821d3b44607534c"),
"title" : "MongoDB Overview",
"description" : "MongoDB is no SQL database",
"by" : "tutorials point",
"url" : "[Link]
"tags" : [
"mongodb",
"database",
"NoSQL"
],
"likes" : 100
}
{
"_id" : ObjectId("5dd4e2cc0821d3b44607534d"),
"title" : "NoSQL Database",
"description" : "NoSQL database doesn't have tables",
"by" : "tutorials point",
"url" : "[Link]
"tags" : [
"mongodb",
"database",
 "NoSQL"
],
"likes" : 20,
"comments" : [
{
"user" : "user1",
"message" : "My first comment",
"dateCreated" : ISODate("2013-12-09T21:05:00Z"),
"like" : 0
}
]
}

El método findOne ()
Aparte del método find (), hay findOne() método, que devuelve solo un documento.

Sintaxis
>[Link]()

Ejemplo
El siguiente ejemplo recupera el documento con el título Descripción general de MongoDB.

> [Link]({title: "MongoDB Overview"})

{
"_id" : ObjectId("5dd6542170fb13eec3963bf0"),
"title" : "MongoDB Overview",
"description" : "MongoDB is no SQL database",
"by" : "tutorials point",
"url" : "[Link]
"tags" : [
"mongodb",
"database",
"NoSQL"
],
"likes" : 100
}
RDBMS Equivalentes de la cláusula Where en
MongoDB
Para consultar el documento sobre la base de alguna condición, puede utilizar las
siguientes operaciones.

Operación Sintaxis Ejemplo Equivalente a RDBMS

Igualdad {<clave>: {$ eg; [Link] ({"por": donde by = 'punto de

<valor>}} "punto de tutoriales'
tutoriales"}). pretty ()

Menos que {<clave>: {$ lt: [Link] ({"me donde me gusta <50

<valor>}} gusta": {$ lt: 50}}).
pretty ()

Menor que {<clave>: {$ lte: [Link] ({"me donde me gusta <= 50

igual <valor>}} gusta": {$ lte: 50}}).
pretty ()

Mas grande {<clave>: {$ gt: [Link] ({"me donde me gusta> 50

que <valor>}} gusta": {$ gt: 50}}).
pretty ()

Mayor que {<clave>: {$ gte: [Link] ({"me donde me gusta> = 50

igual <valor>}} gusta": {$ gte: 50}}).
pretty ()

No es igual {<clave>: {$ ne: [Link] ({"me donde me gusta! = 50

<valor>}} gusta": {$ ne: 50}}).
pretty ()

Valores en {<clave>: {$ en: [Link] Donde el nombre coincide con

una matriz [<valor1>, ({"nombre": {$ in: cualquiera de los valores en:
<valor2>, …… ["Raj", "Ram", ["Raj", "Ram", "Raghu"]
<valorN>]}} "Raghu"]}}). bonita ()
 Valores que {<clave>: {$ nin: [Link] Donde los valores de nombre
no están en <valor>}} ({"nombre": {$ nin: no están en la matriz:
una matriz ["Ramu", "Raghav"]}}). ["Ramu", "Raghav"] o, no
bonita () existe en absoluto

Y en MongoDB
Sintaxis
Para consultar documentos basados en la condición AND, debe usar $ y palabra clave. A
continuación se muestra la sintaxis básica de AND -

>[Link]({ $and: [ {<key1>:<value1>}, { <key2>:<value2>} ] })

Ejemplo
El siguiente ejemplo mostrará todos los tutoriales escritos por 'punto de tutoriales' y cuyo
título es 'Descripción general de MongoDB'.

> [Link]({$and:[{"by":"tutorials point"},{"title": "MongoDB Overview"}

]}).pretty()
{
"_id" : ObjectId("5dd4e2cc0821d3b44607534c"),
"title" : "MongoDB Overview",
"description" : "MongoDB is no SQL database",
"by" : "tutorials point",
"url" : "[Link]
"tags" : [
"mongodb",
"database",
"NoSQL"
],
"likes" : 100
}
>

Para el ejemplo anterior, la cláusula where equivalente será ' where by = 'tutorials point'
AND title = 'MongoDB Overview' '. Puede pasar cualquier número de pares de clave y
valor en la cláusula de búsqueda.

O en MongoDB
Sintaxis
Para consultar documentos basados en la condición OR, debe usar $orpalabra clave. A
continuación se muestra la sintaxis básica deOR -

>[Link](
{
$or: [
{key1: value1}, {key2:value2}
]
}
).pretty()

Ejemplo
El siguiente ejemplo mostrará todos los tutoriales escritos por 'punto de tutoriales' o cuyo
título es 'Descripción general de MongoDB'.

>[Link]({$or:[{"by":"tutorials point"},{"title": "MongoDB Overview"}]}

).pretty()
{
"_id": ObjectId(7df78ad8902c),
"title": "MongoDB Overview",
"description": "MongoDB is no sql database",
"by": "tutorials point",
"url": "[Link]
"tags": ["mongodb", "database", "NoSQL"],
"likes": "100"
}
>

Usando AND y OR juntos

Ejemplo
El siguiente ejemplo mostrará los documentos que tienen gustos superiores a 10 y cuyo
título es "Descripción general de MongoDB" o "punto de tutoriales". SQL equivalente donde
la cláusula es'where likes>10 AND (by = 'tutorials point' OR title = 'MongoDB
Overview')'

>[Link]({"likes": {$gt:10}, $or: [{"by": "tutorials point"},

{"title": "MongoDB Overview"}]}).pretty()
{
 "_id": ObjectId(7df78ad8902c),
"title": "MongoDB Overview",
"description": "MongoDB is no sql database",
"by": "tutorials point",
"url": "[Link]
"tags": ["mongodb", "database", "NoSQL"],
"likes": "100"
}
>

NOR en MongoDB
Sintaxis
Para consultar documentos basados en la condición NOT, debe utilizar la palabra clave $
not. A continuación se muestra la sintaxis básica deNOT -

>db.COLLECTION_NAME.find(
{
$not: [
{key1: value1}, {key2:value2}
]
}
)

Ejemplo
Supongamos que hemos insertado 3 documentos en la colección. empDetails como se
muestra a continuación -

[Link](
[
{
First_Name: "Radhika",
Last_Name: "Sharma",
Age: "26",
e_mail: "radhika_sharma.123@[Link]",
phone: "9000012345"
},
{
 First_Name: "Rachel",
Last_Name: "Christopher",
Age: "27",
e_mail: "Rachel_Christopher.123@[Link]",
phone: "9000054321"
},
{
First_Name: "Fathima",
Last_Name: "Sheik",
Age: "24",
e_mail: "Fathima_Sheik.123@[Link]",
phone: "9000054321"
}
]
)

El siguiente ejemplo recuperará los documentos cuyo nombre no es "Radhika" y el apellido

no es "Christopher".

> [Link](
{
$nor:[
40
{"First_Name": "Radhika"},
{"Last_Name": "Christopher"}
]
}
).pretty()
{
"_id" : ObjectId("5dd631f270fb13eec3963bef"),
"First_Name" : "Fathima",
"Last_Name" : "Sheik",
"Age" : "24",
"e_mail" : "Fathima_Sheik.123@[Link]",
"phone" : "9000054321"
}

NO en MongoDB
Sintaxis
Para consultar documentos basados en la condición NOT, debe usar la palabra clave $
not, la siguiente es la sintaxis básica de NOT -

>db.COLLECTION_NAME.find(
{
$NOT: [
{key1: value1}, {key2:value2}
]
}
).pretty()

Ejemplo
El siguiente ejemplo recuperará los documentos cuya antigüedad no sea superior a 25

> [Link]( { "Age": { $not: { $gt: "25" } } } )

{
"_id" : ObjectId("5dd6636870fb13eec3963bf7"),
"First_Name" : "Fathima",
"Last_Name" : "Sheik",
"Age" : "24",
"e_mail" : "Fathima_Sheik.123@[Link]",
"phone" : "9000054321"
}

MongoDB - Documento de actualización

MongoDB's update() y save()Los métodos se utilizan para actualizar el documento en una
colección. El método update () actualiza los valores en el documento existente mientras
que el método save () reemplaza el documento existente con el documento pasado en el
método save ().

Método MongoDB Update ()

El método update () actualiza los valores en el documento existente.

Sintaxis
La sintaxis básica de update() El método es el siguiente:

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Ejemplo
Considere que la colección mycol tiene los siguientes datos.

{ "_id" : ObjectId(5983548781331adf45ec5), "title":"MongoDB Overview"}

{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"
}

El siguiente ejemplo establecerá el nuevo título 'Nuevo tutorial de MongoDB' de los

documentos cuyo título es 'Descripción general de MongoDB'.

>[Link]({'title':'MongoDB Overview'},{$set:{'title':'New MongoDB Tut

orial'}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
>[Link]()
{ "_id" : ObjectId(5983548781331adf45ec5), "title":"New MongoDB Tutorial"}
{ "_id" : ObjectId(5983548781331adf45ec6), "title":"NoSQL Overview"}
{ "_id" : ObjectId(5983548781331adf45ec7), "title":"Tutorials Point Overview"
}
>

De forma predeterminada, MongoDB actualizará solo un documento. Para actualizar varios

documentos, debe establecer un parámetro 'multi' en verdadero.

>[Link]({'title':'MongoDB Overview'},
{$set:{'title':'New MongoDB Tutorial'}},{multi:true})

Método Save () de MongoDB

los save() El método reemplaza el documento existente con el nuevo documento pasado
en el método save ().

Sintaxis
La sintaxis básica de MongoDB save() El método se muestra a continuación:

>db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

Ejemplo
El siguiente ejemplo reemplazará el documento con el _id '5983548781331adf45ec5'.

>[Link](
{
"_id" : ObjectId("507f191e810c19729de860ea"),
 "title":"Tutorials Point New Topic",
"by":"Tutorials Point"
}
)
WriteResult({
"nMatched" : 0,
"nUpserted" : 1,
"nModified" : 0,
"_id" : ObjectId("507f191e810c19729de860ea")
})
>[Link]()
{ "_id" : ObjectId("507f191e810c19729de860e6"), "title":"Tutorials Point New
Topic",
"by":"Tutorials Point"}
{ "_id" : ObjectId("507f191e810c19729de860e6"), "title":"NoSQL Overview"}
{ "_id" : ObjectId("507f191e810c19729de860e6"), "title":"Tutorials Point Over
view"}
>

Método findOneAndUpdate () de MongoDB

los findOneAndUpdate() El método actualiza los valores en el documento existente.

Sintaxis
La sintaxis básica de findOneAndUpdate() El método es el siguiente:

>db.COLLECTION_NAME.findOneAndUpdate(SELECTIOIN_CRITERIA, UPDATED_DATA)

Ejemplo
Supongamos que hemos creado una colección llamada empDetails e insertado tres
documentos en ella como se muestra a continuación:

> [Link](
[
{
First_Name: "Radhika",
Last_Name: "Sharma",
Age: "26",
e_mail: "radhika_sharma.123@[Link]",
phone: "9000012345"
 },
{
First_Name: "Rachel",
Last_Name: "Christopher",
Age: "27",
e_mail: "Rachel_Christopher.123@[Link]",
phone: "9000054321"
},
{
First_Name: "Fathima",
Last_Name: "Sheik",
Age: "24",
e_mail: "Fathima_Sheik.123@[Link]",
phone: "9000054321"
}
]
)

El siguiente ejemplo actualiza la edad y los valores de correo electrónico del documento
con el nombre 'Radhika'.

> [Link](
{First_Name: 'Radhika'},
{ $set: { Age: '30',e_mail: 'radhika_newemail@[Link]'}}
)
{
"_id" : ObjectId("5dd6636870fb13eec3963bf5"),
"First_Name" : "Radhika",
"Last_Name" : "Sharma",
"Age" : "30",
"e_mail" : "radhika_newemail@[Link]",
"phone" : "9000012345"
}

Método updateOne () de MongoDB

Este método actualiza un solo documento que coincide con el filtro dado.
Sintaxis
La sintaxis básica del método updateOne () es la siguiente:

>db.COLLECTION_NAME.updateOne(<filter>, <update>)

Ejemplo
> [Link](
{First_Name: 'Radhika'},
{ $set: { Age: '30',e_mail: 'radhika_newemail@[Link]'}}
)
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 0 }
>

Método updateMany () de MongoDB

El método updateMany () actualiza todos los documentos que coinciden con el filtro dado.

Sintaxis
La sintaxis básica del método updateMany () es la siguiente:

>db.COLLECTION_NAME.update(<filter>, <update>)

Ejemplo
> [Link](
{Age:{ $gt: "25" }},
{ $set: { Age: '00'}}
)
{ "acknowledged" : true, "matchedCount" : 2, "modifiedCount" : 2 }

Puede ver los valores actualizados si recupera el contenido del documento utilizando el
método de búsqueda como se muestra a continuación:

> [Link]()
{ "_id" : ObjectId("5dd6636870fb13eec3963bf5"), "First_Name" : "Radhika", "La
st_Name" : "Sharma", "Age" : "00", "e_mail" : "radhika_newemail@[Link]", "
phone" : "9000012345" }
{ "_id" : ObjectId("5dd6636870fb13eec3963bf6"), "First_Name" : "Rachel", "Las
t_Name" : "Christopher", "Age" : "00", "e_mail" : "Rachel_Christopher.123@gma
[Link]", "phone" : "9000054321" }
{ "_id" : ObjectId("5dd6636870fb13eec3963bf7"), "First_Name" : "Fathima", "La
st_Name" : "Sheik", "Age" : "24", "e_mail" : "Fathima_Sheik.123@[Link]", "
phone" : "9000054321" }

MongoDB - Eliminar documento

En este capítulo, aprenderemos cómo eliminar un documento usando MongoDB.

El método remove ()
MongoDB's remove()El método se utiliza para eliminar un documento de la colección. El
método remove () acepta dos parámetros. Uno es el criterio de eliminación y el segundo es
solo una bandera.
• deletion criteria - Se eliminarán los criterios de eliminación (opcional) de acuerdo
con los documentos.
• justOne - (Opcional) si se establece en verdadero o 1, elimine solo un documento.

Sintaxis
Sintaxis básica de remove() El método es el siguiente:

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

Ejemplo
Considere que la colección mycol tiene los siguientes datos.

{_id : ObjectId("507f191e810c19729de860e1"), title: "MongoDB Overview"},

{_id : ObjectId("507f191e810c19729de860e2"), title: "NoSQL Overview"},
{_id : ObjectId("507f191e810c19729de860e3"), title: "Tutorials Point Overview
"}

El siguiente ejemplo eliminará todos los documentos cuyo título sea 'Descripción general
de MongoDB'.

>[Link]({'title':'MongoDB Overview'})
WriteResult({"nRemoved" : 1})
> [Link]()
{"_id" : ObjectId("507f191e810c19729de860e2"), "title" : "NoSQL Overview" }
{"_id" : ObjectId("507f191e810c19729de860e3"), "title" : "Tutorials Point Ove
rview" }

Quitar solo uno

Si hay varios registros y desea eliminar solo el primer registro,
establezca justOne parámetro en remove() método.
>db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)

Eliminar todos los documentos

Si no especifica los criterios de eliminación, MongoDB eliminará documentos completos de
la colección. This is equivalent of SQL's truncate command.

> [Link]({})
WriteResult({ "nRemoved" : 2 })
> [Link]()

MongoDB - Proyección
En MongoDB, la proyección significa seleccionar solo los datos necesarios en lugar de
seleccionar todos los datos de un documento. Si un documento tiene 5 campos y solo
necesita mostrar 3, seleccione solo 3 de ellos.

El método find ()
MongoDB's find(), explicado en MongoDB Query Document acepta el segundo parámetro
opcional que es la lista de campos que desea recuperar. En MongoDB, cuando
ejecutafind()método, luego muestra todos los campos de un documento. Para limitar esto,
debe establecer una lista de campos con valor 1 o 0. Se usa 1 para mostrar el campo
mientras que 0 se usa para ocultar los campos.

Sintaxis
La sintaxis básica de find() El método con proyección es el siguiente:

>db.COLLECTION_NAME.find({},{KEY:1})

Ejemplo
Considere la colección mycol tiene los siguientes datos:

{_id : ObjectId("507f191e810c19729de860e1"), title: "MongoDB Overview"},

{_id : ObjectId("507f191e810c19729de860e2"), title: "NoSQL Overview"},
{_id : ObjectId("507f191e810c19729de860e3"), title: "Tutorials Point Overview
"}

El siguiente ejemplo mostrará el título del documento mientras consulta el documento.

>[Link]({},{"title":1,_id:0})
{"title":"MongoDB Overview"}
{"title":"NoSQL Overview"}
{"title":"Tutorials Point Overview"}
>

tenga en cuenta _id El campo siempre se muestra mientras se ejecuta find() método, si no
desea este campo, debe establecerlo como 0.

MongoDB - Límite de registros

En este capítulo, aprenderemos cómo limitar registros usando MongoDB.

El método Limit ()
Para limitar los registros en MongoDB, debe usar limit()método. El método acepta un
argumento de tipo numérico, que es el número de documentos que desea que se
muestren.

Sintaxis
La sintaxis básica de limit() El método es el siguiente:

>db.COLLECTION_NAME.find().limit(NUMBER)

Ejemplo
Considere la colección myycol tiene los siguientes datos.

{_id : ObjectId("507f191e810c19729de860e1"), title: "MongoDB Overview"},

{_id : ObjectId("507f191e810c19729de860e2"), title: "NoSQL Overview"},
{_id : ObjectId("507f191e810c19729de860e3"), title: "Tutorials Point Overview
"}

El siguiente ejemplo mostrará solo dos documentos al consultar el documento.

>[Link]({},{"title":1,_id:0}).limit(2)
{"title":"MongoDB Overview"}
{"title":"NoSQL Overview"}
>

Si no especifica el argumento de número en limit() luego mostrará todos los documentos

de la colección.

Método MongoDB Skip ()

Aparte del método limit (), hay un método más skip() que también acepta el argumento de
tipo de número y se utiliza para omitir el número de documentos.

Sintaxis
La sintaxis básica de skip() El método es el siguiente:
>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

Ejemplo
El siguiente ejemplo mostrará solo el segundo documento.

>[Link]({},{"title":1,_id:0}).limit(1).skip(1)
{"title":"NoSQL Overview"}
>

Tenga en cuenta que el valor predeterminado en skip() el método es 0.

MongoDB - Ordenar registros

En este capítulo, aprenderemos cómo ordenar registros en MongoDB.

El método sort ()
Para ordenar documentos en MongoDB, debe usar sort()método. El método acepta un
documento que contiene una lista de campos junto con su orden de clasificación. Para
especificar el orden de clasificación se utilizan 1 y -1. 1 se usa para orden ascendente
mientras que -1 se usa para orden descendente.

Sintaxis
La sintaxis básica de sort() El método es el siguiente:

>db.COLLECTION_NAME.find().sort({KEY:1})

Ejemplo
Considere la colección myycol tiene los siguientes datos.

{_id : ObjectId("507f191e810c19729de860e1"), title: "MongoDB Overview"}

{_id : ObjectId("507f191e810c19729de860e2"), title: "NoSQL Overview"}
{_id : ObjectId("507f191e810c19729de860e3"), title: "Tutorials Point Overview
"}

El siguiente ejemplo mostrará los documentos ordenados por título en orden descendente.

>[Link]({},{"title":1,_id:0}).sort({"title":-1})
{"title":"Tutorials Point Overview"}
{"title":"NoSQL Overview"}
{"title":"MongoDB Overview"}
>
Tenga en cuenta que si no especifica la preferencia de clasificación, sort() El método
mostrará los documentos en orden ascendente.

MongoDB - Indexación
Los índices apoyan la resolución eficiente de consultas. Sin índices, MongoDB debe
escanear todos los documentos de una colección para seleccionar aquellos documentos
que coincidan con la declaración de consulta. Este análisis es muy ineficaz y requiere que
MongoDB procese un gran volumen de datos.
Los índices son estructuras de datos especiales que almacenan una pequeña parte del
conjunto de datos en una forma fácil de recorrer. El índice almacena el valor de un campo
específico o un conjunto de campos, ordenados por el valor del campo como se especifica
en el índice.

El método createIndex ()
Para crear un índice, debe utilizar el método createIndex () de MongoDB.

Sintaxis
La sintaxis básica de createIndex() El método es el siguiente ().

>db.COLLECTION_NAME.createIndex({KEY:1})

Aquí la clave es el nombre del campo en el que desea crear el índice y 1 es para el orden
ascendente. Para crear un índice en orden descendente, debe usar -1.

Ejemplo
>[Link]({"title":1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
>

En createIndex() método puede pasar varios campos, para crear un índice en varios
campos.

>[Link]({"title":1,"description":-1})
>

Este método también acepta una lista de opciones (que son opcionales). A continuación se
muestra la lista:
Parámetro Tipo Descripción

antecedentes Booleano Crea el índice en segundo plano para que la creación de

un índice no bloquee otras actividades de la base de
datos. Especifique verdadero para construir en
segundo plano. El valor predeterminado esfalse.

único Booleano Crea un índice único para que la colección no acepte la

inserción de documentos donde la clave o claves de
índice coinciden con un valor existente en el índice.
Especifique verdadero para crear un índice único. El
valor predeterminado esfalse.

nombre cuerda El nombre del índice. Si no se especifica, MongoDB

genera un nombre de índice concatenando los
nombres de los campos indexados y el orden de
clasificación.

escaso Booleano Si es verdadero, el índice solo hace referencia a

documentos con el campo especificado. Estos índices
utilizan menos espacio pero se comportan de manera
diferente en algunas situaciones (en particular, en los
tipos). El valor predeterminado esfalse.

expireAfterSeconds entero Especifica un valor, en segundos, como TTL para

controlar cuánto tiempo MongoDB retiene los
documentos de esta colección.

pesos documento El peso es un número que va de 1 a 99,999 y denota la

importancia del campo en relación con los otros
campos indexados en términos de la puntuación.

idioma cuerda Para un índice de texto, el idioma que determina la lista

predeterminado de palabras vacías y las reglas para el lematizador y el
tokenizador. El valor predeterminado esEnglish.

language_override cuerda Para un índice de texto, especifique el nombre del

campo en el documento que contiene el idioma para
 reemplazar el idioma predeterminado. El valor
predeterminado es el idioma.

El método dropIndex ()
Puede eliminar un índice en particular utilizando el método dropIndex () de MongoDB.

Sintaxis
La sintaxis básica del método DropIndex () es la siguiente ().

>db.COLLECTION_NAME.dropIndex({KEY:1})

Aquí la clave es el nombre del archivo en el que desea crear el índice y 1 es para el orden
ascendente. Para crear un índice en orden descendente, debe usar -1.

Ejemplo
> [Link]({"title":1})
{
"ok" : 0,
"errmsg" : "can't find index with key: { title: 1.0 }",
"code" : 27,
"codeName" : "IndexNotFound"
}

El método dropIndexes ()
Este método elimina varios índices (especificados) en una colección.

Sintaxis
La sintaxis básica del método DropIndexes () es la siguiente () -

>db.COLLECTION_NAME.dropIndexes()

Ejemplo
Suponga que hemos creado 2 índices en la colección mycol nombrada como se muestra a
continuación:

> [Link]({"title":1,"description":-1})

El siguiente ejemplo elimina los índices de mycol creados anteriormente:

>[Link]({"title":1,"description":-1})
{ "nIndexesWas" : 2, "ok" : 1 }
>

El método getIndexes ()
Este método devuelve la descripción de todos los índices de la colección.

Sintaxis
A continuación se muestra la sintaxis básica del método getIndexes ():

db.COLLECTION_NAME.getIndexes()

Ejemplo
Suponga que hemos creado 2 índices en la colección mycol nombrada como se muestra a
continuación:

> [Link]({"title":1,"description":-1})

El siguiente ejemplo recupera todos los índices de la colección mycol:

> [Link]()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "[Link]"
},
{
"v" : 2,
"key" : {
"title" : 1,
"description" : -1
},
"name" : "title_1_description_-1",
"ns" : "[Link]"
}
]
MongoDB - Agregación
Las operaciones de agregaciones procesan registros de datos y devuelven resultados
calculados. Las operaciones de agregación agrupan valores de varios documentos y
pueden realizar una variedad de operaciones en los datos agrupados para devolver un
solo resultado. En SQL count (*) y con group by es un equivalente de la agregación
MongoDB.

El método aggregate ()
Para la agregación en MongoDB, debe usar aggregate() método.

Sintaxis
Sintaxis básica de aggregate() El método es el siguiente:

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

Ejemplo
En la colección tienes los siguientes datos:

{
_id: ObjectId(7df78ad8902c)
title: 'MongoDB Overview',
description: 'MongoDB is no sql database',
by_user: 'tutorials point',
url: '[Link]
tags: ['mongodb', 'database', 'NoSQL'],
likes: 100
},
{
_id: ObjectId(7df78ad8902d)
title: 'NoSQL Overview',
description: 'No sql database is very fast',
by_user: 'tutorials point',
url: '[Link]
tags: ['mongodb', 'database', 'NoSQL'],
likes: 10
},
{
_id: ObjectId(7df78ad8902e)
 title: 'Neo4j Overview',
description: 'Neo4j is no sql database',
by_user: 'Neo4j',
url: '[Link]
tags: ['neo4j', 'database', 'NoSQL'],
likes: 750
},

Ahora, de la colección anterior, si desea mostrar una lista que indique cuántos tutoriales ha
escrito cada usuario, utilizará lo siguiente aggregate() método -

> [Link]([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}

}])
{ "_id" : "tutorials point", "num_tutorial" : 2 }
{ "_id" : "Neo4j", "num_tutorial" : 1 }
>

La consulta equivalente de SQL para el caso de uso anterior será select by_user,
count(*) from mycol group by by_user.
En el ejemplo anterior, hemos agrupado los documentos por campo. by_usery en cada
aparición del usuario se incrementa el valor anterior de la suma. A continuación se muestra
una lista de expresiones de agregación disponibles.

Expresión Descripción Ejemplo

$ suma Suma el valor definido de todos los documentos [Link] ([{$

de la colección. grupo: {_id: "$
por_usuario",
num_tutorial: {suma:" me
gusta"}}}])

$ Calcula el promedio de todos los valores dados [Link] ([{$

promedio de todos los documentos de la colección. grupo: {_id: "$ by_user",
num_tutorial:
{avg:" likes"}}}])

$ min Obtiene el mínimo de los valores [Link] ([{$

correspondientes de todos los documentos de la grupo: {_id: "$
colección. por_usuario",
num_tutorial: {min:" me
gusta"}}}])
 $ máximo Obtiene el máximo de los valores [Link] ([{$
correspondientes de todos los documentos de la grupo: {_id: "$
colección. por_usuario",
num_tutorial: {max:" me
gusta"}}}])

$ Inserta el valor en una matriz en el documento [Link] ([{$

empujar resultante. grupo: {_id: "$
por_usuario", url:
{push:" url"}}}])

$ Inserta el valor en una matriz en el documento [Link] ([{$

addToSet resultante, pero no crea duplicados. grupo: {_id: "$
por_usuario", url:
{addToSet:" url"}}}])

$ primero Obtiene el primer documento de los [Link] ([{$

documentos de origen según la agrupación. Por grupo: {_id: "$
lo general, esto solo tiene sentido junto con por_usuario", primera_url:
alguna etapa "$ sort" aplicada previamente. {primero:" url"}}}])

$ último Obtiene el último documento de los documentos [Link] ([{$

de origen según la agrupación. Por lo general, grupo: {_id: "$ by_user",
esto solo tiene sentido junto con alguna etapa "$ last_url: {last:" url"}}}])
sort" aplicada previamente.

Concepto de tubería
En el comando UNIX, la canalización de shell significa la posibilidad de ejecutar una
operación en alguna entrada y usar la salida como entrada para el siguiente comando y así
sucesivamente. MongoDB también admite el mismo concepto en el marco de agregación.
Existe un conjunto de etapas posibles y cada una de ellas se toma como un conjunto de
documentos como entrada y produce un conjunto resultante de documentos (o el
documento JSON resultante final al final de la canalización). Esto, a su vez, se puede
utilizar para la siguiente etapa y así sucesivamente.
Las siguientes son las posibles etapas en el marco de agregación:
• $project - Se utiliza para seleccionar algunos campos específicos de una
colección.
• $match - Esta es una operación de filtrado y, por lo tanto, puede reducir la
cantidad de documentos que se dan como entrada a la siguiente etapa.
• $group - Esto hace la agregación real como se discutió anteriormente.
• $sort - Ordena los documentos.
 • $skip - Con esto, es posible saltar hacia adelante en la lista de documentos para
una cantidad determinada de documentos.
• $limit - Esto limita la cantidad de documentos a mirar, por el número dado a partir
de las posiciones actuales.
• $unwind- Se utiliza para desenrollar documentos que utilizan matrices. Cuando se
usa una matriz, los datos se unen previamente y esta operación se deshará con
esto para tener documentos individuales nuevamente. Así, con esta etapa
aumentaremos la cantidad de documentos para la siguiente etapa.

MongoDB - Replicación
La replicación es el proceso de sincronizar datos en varios servidores. La replicación
proporciona redundancia y aumenta la disponibilidad de datos con múltiples copias de
datos en diferentes servidores de bases de datos. La replicación protege una base de
datos de la pérdida de un solo servidor. La replicación también le permite recuperarse de
fallas de hardware e interrupciones del servicio. Con copias adicionales de los datos,
puede dedicar una a la recuperación de desastres, generación de informes o respaldo.

¿Por qué la replicación?

• Para mantener sus datos seguros
• Alta disponibilidad de datos (24 * 7)
• Recuperación de desastres
• Sin tiempo de inactividad por mantenimiento (como copias de seguridad,
reconstrucciones de índices, compactación)
• Escala de lectura (copias adicionales para leer)
• El conjunto de réplicas es transparente para la aplicación

Cómo funciona la replicación en MongoDB

MongoDB logra la replicación mediante el uso de un conjunto de réplicas. Un conjunto de
réplicas es un grupo demongodinstancias que alojan el mismo conjunto de datos. En una
réplica, un nodo es el nodo principal que recibe todas las operaciones de escritura. Todas
las demás instancias, como las secundarias, aplican operaciones desde la primaria para
que tengan el mismo conjunto de datos. El conjunto de réplicas solo puede tener un nodo
principal.
• El conjunto de réplicas es un grupo de dos o más nodos (generalmente se requiere
un mínimo de 3 nodos).
• En un conjunto de réplicas, un nodo es el nodo principal y los nodos restantes son
secundarios.
• Todos los datos se replican del nodo primario al secundario.
• En el momento de la conmutación por error automática o el mantenimiento, se
establece la elección para el nodo primario y se elige un nuevo nodo primario.
• Después de la recuperación del nodo fallido, vuelve a unirse al conjunto de réplicas
y funciona como nodo secundario.
Se muestra un diagrama típico de la replicación de MongoDB en el que la aplicación
cliente siempre interactúa con el nodo principal y el nodo principal luego replica los datos
en los nodos secundarios.
Funciones del conjunto de réplicas
• Un grupo de N nodos
• Cualquier nodo puede ser primario
• Todas las operaciones de escritura van al primario
• Conmutación por error automática
• Recuperación automática
• Elección de consenso de primarias

Configurar un conjunto de réplicas

En este tutorial, convertiremos una instancia de MongoDB independiente en un conjunto
de réplicas. Para convertir a un conjunto de réplicas, los siguientes son los pasos:
• Apague el servidor MongoDB que ya está ejecutando.
•
• Inicie el servidor MongoDB especificando la opción - replSet. A continuación se
muestra la sintaxis básica de --replSet -

mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INST

ANCE_NAME"

Ejemplo
mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0
 • Comenzará una instancia de mongod con el nombre rs0, en el puerto 27017.
• Ahora inicie el símbolo del sistema y conéctese a esta instancia de mongod.
• En el cliente Mongo, emita el comando [Link]() para iniciar un nuevo conjunto
de réplicas.
• Para verificar la configuración del conjunto de réplicas, emita el comando [Link]().
Para comprobar el estado del conjunto de réplicas, emita el [Link]().

Agregar miembros al conjunto de réplicas

Para agregar miembros al conjunto de réplicas, inicie instancias de mongod en varias
máquinas. Ahora inicie un cliente mongo y emita un [Link]().

Sintaxis
La sintaxis básica de [Link]() El comando es el siguiente:

>[Link](HOST_NAME:PORT)

Ejemplo
Suponga que el nombre de su instancia mongod es [Link] y se está ejecutando en
el puerto 27017. Para agregar esta instancia al conjunto de réplicas, emita el
[Link]() en el cliente Mongo.

>[Link]("[Link]")
>

Puede agregar una instancia de mongod al conjunto de réplicas solo cuando esté
conectado al nodo principal. Para verificar si está conectado al primario o no, emita el
[Link]() en cliente mongo.

MongoDB: fragmentación
Sharding es el proceso de almacenar registros de datos en múltiples máquinas y es el
enfoque de MongoDB para satisfacer las demandas del crecimiento de datos. A medida
que aumenta el tamaño de los datos, es posible que una sola máquina no sea suficiente
para almacenar los datos ni proporcionar un rendimiento de lectura y escritura aceptable.
La fragmentación resuelve el problema de la escala horizontal. Con la fragmentación,
agrega más máquinas para respaldar el crecimiento de datos y las demandas de las
operaciones de lectura y escritura.

¿Por qué Sharding?

• En la replicación, todas las escrituras van al nodo maestro
• Las consultas sensibles a la latencia aún van a master
• El conjunto de réplicas único tiene una limitación de 12 nodos
• La memoria no puede ser lo suficientemente grande cuando el conjunto de datos
activo es grande
 • El disco local no es lo suficientemente grande
• El escalado vertical es demasiado caro

Fragmentación en MongoDB
El siguiente diagrama muestra la fragmentación en MongoDB utilizando un clúster
fragmentado.

En el siguiente diagrama, hay tres componentes principales:

• Shards- Los fragmentos se utilizan para almacenar datos. Proporcionan alta
disponibilidad y consistencia de datos. En el entorno de producción, cada
fragmento es un conjunto de réplicas independiente.
• Config Servers- Los servidores de configuración almacenan los metadatos del
clúster. Estos datos contienen una asignación del conjunto de datos del clúster a
los fragmentos. El enrutador de consultas usa estos metadatos para orientar
operaciones a fragmentos específicos. En el entorno de producción, los clústeres
fragmentados tienen exactamente 3 servidores de configuración.
• Query Routers- Los enrutadores de consultas son básicamente instancias de
mongo, interactúan con las aplicaciones cliente y dirigen las operaciones al
fragmento apropiado. El enrutador de consultas procesa y dirige las operaciones a
fragmentos y luego devuelve los resultados a los clientes. Un clúster fragmentado
puede contener más de un enrutador de consultas para dividir la carga de
solicitudes del cliente. Un cliente envía solicitudes a un enrutador de consultas.
Generalmente, un clúster fragmentado tiene muchos enrutadores de consultas.

MongoDB - Crear copia de seguridad

En este capítulo, veremos cómo crear una copia de seguridad en MongoDB.

Volcar datos de MongoDB

Para crear una copia de seguridad de la base de datos en MongoDB, debe
usar mongodumpmando. Este comando volcará todos los datos de su servidor en el
directorio de volcado. Hay muchas opciones disponibles mediante las cuales puede limitar
la cantidad de datos o crear una copia de seguridad de su servidor remoto.

Sintaxis
La sintaxis básica de mongodump El comando es el siguiente:

>mongodump

Ejemplo
Inicie su servidor mongod. Suponiendo que su servidor mongod se está ejecutando en el
localhost y el puerto 27017, abra un símbolo del sistema y vaya al directorio bin de su
instancia de mongodb y escriba el comandomongodump
Considere que la colección mycol tiene los siguientes datos.

>mongodump

El comando se conectará al servidor que se ejecuta en [Link] y puerto 27017 y volver

todos los datos del servidor al directorio /bin/dump/. A continuación se muestra la salida
del comando:

A continuación se muestra una lista de opciones disponibles que se pueden utilizar con
el mongodump mando.

Sintaxis Descripción Ejemplo

 mongodump --host Este comando respaldará todas las mongodump --host
HOST_NAME --port bases de datos de la instancia [Link] --port
PORT_NUMBER mongod especificada. 27017

mongodump --dbpath Este comando respaldará solo la mongodump --dbpath /

DB_PATH --out base de datos especificada en la data / db / --out / data /
BACKUP_DIRECTORY ruta especificada. backup /

mongodump --collection Este comando respaldará solo la mongodump --collection

COLLECTION --db colección especificada de la base mycol --db test
DB_NAME de datos especificada.

Restaurar datos
Para restaurar los datos de respaldo de MongoDB mongorestorese utiliza el comando.
Este comando restaura todos los datos del directorio de respaldo.

Sintaxis
La sintaxis básica de mongorestore el comando es -

>mongorestore

A continuación se muestra la salida del comando:

MongoDB - Relaciones
Las relaciones en MongoDB representan cómo varios documentos se relacionan
lógicamente entre sí. Las relaciones se pueden modelar mediante
Embedded y Referenced enfoques. Tales relaciones pueden ser 1: 1, 1: N, N: 1 o N: N.
Consideremos el caso de almacenar direcciones para usuarios. Por lo tanto, un usuario
puede tener varias direcciones, lo que hace que esta sea una relación 1: N.
A continuación se muestra la estructura del documento de muestra de user documento -

{
"_id":ObjectId("52ffc33cd85242f436000001"),
"name": "Tom Hanks",
"contact": "987654321",
"dob": "01-01-1991"
}

A continuación se muestra la estructura del documento de muestra de address documento

-

{
"_id":ObjectId("52ffc4a5d85242602e000000"),
"building": "22 A, Indiana Apt",
"pincode": 123456,
"city": "Los Angeles",
"state": "California"
}

Modelado de relaciones incrustadas

En el enfoque integrado, integraremos el documento de dirección dentro del documento
del usuario.

> [Link]({
{
"_id":ObjectId("52ffc33cd85242f436000001"),
"contact": "987654321",
"dob": "01-01-1991",
"name": "Tom Benzamin",
"address": [
 {
"building": "22 A, Indiana Apt",
"pincode": 123456,
"city": "Los Angeles",
"state": "California"
},
{
"building": "170 A, Acropolis Apt",
"pincode": 456789,
"city": "Chicago",
"state": "Illinois"
}
]
}
})

Este enfoque mantiene todos los datos relacionados en un solo documento, lo que facilita
su recuperación y mantenimiento. El documento completo se puede recuperar en una sola
consulta, como:

>[Link]({"name":"Tom Benzamin"},{"address":1})

Tenga en cuenta que en la consulta anterior, db y users son la base de datos y la

colección respectivamente.
El inconveniente es que si el documento incrustado sigue creciendo demasiado, puede
afectar el rendimiento de lectura / escritura.

Modelado de relaciones referenciadas

Este es el enfoque para diseñar una relación normalizada. En este enfoque, tanto los
documentos de usuario como los de dirección se mantendrán por separado, pero el
documento de usuario contendrá un campo que hará referencia al documento de
direcció[Link] campo.

{
"_id":ObjectId("52ffc33cd85242f436000001"),
"contact": "987654321",
"dob": "01-01-1991",
"name": "Tom Benzamin",
"address_ids": [
ObjectId("52ffc4a5d85242602e000000"),
ObjectId("52ffc4a5d85242602e000001")
 ]
}

Como se muestra arriba, el documento de usuario contiene el campo de

matriz address_idsque contiene ObjectIds de las direcciones correspondientes. Usando
estos ObjectIds, podemos consultar los documentos de dirección y obtener detalles de la
dirección desde allí. Con este enfoque, necesitaremos dos consultas: primero para obtener
eladdress_ids campos de user documento y segundo para obtener estas direcciones
de address colección.

>var result = [Link]({"name":"Tom Benzamin"},{"address_ids":1})

>var addresses = [Link]({"_id":{"$in":result["address_ids"]}})

MongoDB - Consultas cubiertas

En este capítulo, aprenderemos acerca de las consultas cubiertas.

¿Qué es una consulta cubierta?

Según la documentación oficial de MongoDB, una consulta cubierta es una consulta en la
que:

• Todos los campos de la consulta forman parte de un índice.

• Todos los campos devueltos en la consulta están en el mismo índice.

Dado que todos los campos presentes en la consulta son parte de un índice, MongoDB
coincide con las condiciones de la consulta y devuelve el resultado utilizando el mismo
índice sin mirar dentro de los documentos. Dado que los índices están presentes en la
RAM, la obtención de datos de índices es mucho más rápida en comparación con la
obtención de datos mediante el escaneo de documentos.

Usar consultas cubiertas

Para probar las consultas cubiertas, considere el siguiente documento en
el users colección -

{
"_id": ObjectId("53402597d852426020000003"),
"contact": "987654321",
"dob": "01-01-1991",
"gender": "M",
"name": "Tom Benzamin",
"user_name": "tombenzamin"
}
Primero crearemos un índice compuesto para el users colección en los
campos gender y user_name usando la siguiente consulta -

>[Link]({gender:1,user_name:1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}

Ahora, este índice cubrirá la siguiente consulta:

>[Link]({gender:"M"},{user_name:1,_id:0})
{ "user_name" : "tombenzamin" }

Es decir, para la consulta anterior, MongoDB no buscaría documentos de base de datos.

En su lugar, obtendría los datos requeridos de los datos indexados, lo que es muy rápido.
Dado que nuestro índice no incluye _id, lo hemos excluido explícitamente del conjunto de
resultados de nuestra consulta, ya que MongoDB de forma predeterminada devuelve el
campo _id en cada consulta. Por lo tanto, la siguiente consulta no se habría cubierto
dentro del índice creado anteriormente:

>[Link]({gender:"M"},{user_name:1})
{ "_id" : ObjectId("53402597d852426020000003"), "user_name" : "tombenzamin" }

Por último, recuerde que un índice no puede cubrir una consulta si:

• Cualquiera de los campos indexados es una matriz

• Cualquiera de los campos indexados es un subdocumento

MongoDB: análisis de consultas

El análisis de consultas es un aspecto muy importante para medir la eficacia de la base de
datos y el diseño de indexación. Aprenderemos sobre los de uso
frecuente$explain y $hint consultas.

Usando $ explicar
los $explainEl operador proporciona información sobre la consulta, los índices utilizados
en una consulta y otras estadísticas. Es muy útil al analizar qué tan bien están optimizados
sus índices.
En el último capítulo, ya habíamos creado un índice para el users colección en
campos gender y user_name usando la siguiente consulta -
>[Link]({gender:1,user_name:1})
{
"numIndexesBefore" : 2,
"numIndexesAfter" : 2,
"note" : "all indexes already exist",
"ok" : 1
}

Ahora usaremos $explain en la siguiente consulta:

>[Link]({gender:"M"},{user_name:1,_id:0}).explain()

La consulta explica () anterior devuelve el siguiente resultado analizado:

{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "[Link]",
"indexFilterSet" : false,
"parsedQuery" : {
"gender" : {
"$eq" : "M"
}
},
"queryHash" : "B4037D3C",
"planCacheKey" : "DEAAE17C",
"winningPlan" : {
"stage" : "PROJECTION_COVERED",
"transformBy" : {
"user_name" : 1,
"_id" : 0
},
"inputStage" : {
"stage" : "IXSCAN",
"keyPattern" : {
"gender" : 1,
"user_name" : 1
},
 "indexName" : "gender_1_user_name_1",
"isMultiKey" : false,
"multiKeyPaths" : {
"gender" : [ ],
"user_name" : [ ]
},
"isUnique" : false,
"isSparse" : false,
"isPartial" : false,
"indexVersion" : 2,
"direction" : "forward",
"indexBounds" : {
"gender" : [
"[\"M\", \"M\"]"
],
"user_name" : [
"[MinKey, MaxKey]"
]
}
}
},
"rejectedPlans" : [ ]
},
"serverInfo" : {
"host" : "Krishna",
"port" : 27017,
"version" : "4.2.1",
"gitVersion" : "edf6d45851c0b9ee15548f0f847df141764a317e"
},
"ok" : 1
}

Ahora veremos los campos en este conjunto de resultados:

• El verdadero valor de indexOnly indica que esta consulta ha utilizado la
indexación.
• los cursorcampo especifica el tipo de cursor utilizado. El tipo BTreeCursor indica
que se utilizó un índice y también da el nombre del índice utilizado. BasicCursor
indica que se realizó un análisis completo sin utilizar ningún índice.
 • n indica el número de documentos que coinciden devueltos.
• nscannedObjects indica el número total de documentos escaneados.
• nscanned indica el número total de documentos o entradas de índice escaneados.

Usando $ hint
los $hintEl operador obliga al optimizador de consultas a utilizar el índice especificado
para ejecutar una consulta. Esto es particularmente útil cuando desea probar el
rendimiento de una consulta con diferentes índices. Por ejemplo, la siguiente consulta
especifica el índice en los camposgender y user_name que se utilizará para esta
consulta:

>[Link]({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1})
{ "user_name" : "tombenzamin" }

Para analizar la consulta anterior usando $ explicar:

>[Link]({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1})
.explain()

Lo que le da el siguiente resultado:

{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "[Link]",
"indexFilterSet" : false,
"parsedQuery" : {
"gender" : {
"$eq" : "M"
}
},
"queryHash" : "B4037D3C",
"planCacheKey" : "DEAAE17C",
"winningPlan" : {
"stage" : "PROJECTION_COVERED",
"transformBy" : {
"user_name" : 1,
"_id" : 0
},
"inputStage" : {
"stage" : "IXSCAN",
 "keyPattern" : {
"gender" : 1,
"user_name" : 1
},
"indexName" : "gender_1_user_name_1",
"isMultiKey" : false,
"multiKeyPaths" : {
"gender" : [ ],
"user_name" : [ ]
},
"isUnique" : false,
"isSparse" : false,
"isPartial" : false,
"indexVersion" : 2,
"direction" : "forward",
"indexBounds" : {
"gender" : [
"[\"M\", \"M\"]"
],
"user_name" : [
"[MinKey, MaxKey]"
]
}
}
},
"rejectedPlans" : [ ]
},
"serverInfo" : {
"host" : "Krishna",
"port" : 27017,
"version" : "4.2.1",
109
"gitVersion" : "edf6d45851c0b9ee15548f0f847df141764a317e"
},
"ok" : 1
}
MongoDB - Operaciones atómicas
Datos del modelo para operaciones atómicas
El enfoque recomendado para mantener la atomicidad sería mantener toda la información
relacionada, que con frecuencia se actualiza junta en un solo documento
utilizando embedded documents. Esto aseguraría que todas las actualizaciones de un
solo documento sean atómicas.
Supongamos que hemos creado una colección con el nombre productDetails e insertamos
documentos en ella como se muestra a continuación:

>[Link]("products")
{ "ok" : 1 }
> [Link](
{
"_id":1,
"product_name": "Samsung S3",
"category": "mobiles",
"product_total": 5,
"product_available": 3,
"product_bought_by": [
{
"customer": "john",
"date": "7-Jan-2014"
},
{
"customer": "mark",
"date": "8-Jan-2014"
}
]
}
)
WriteResult({ "nInserted" : 1 })
>

En este documento, hemos incorporado la información del cliente que compra el producto
en el product_bought_by campo. Ahora, cada vez que un nuevo cliente compra el
producto, primero verificaremos si el producto todavía está disponible
usandoproduct_available campo. Si está disponible, reduciremos el valor del campo
product_available e insertaremos el documento incrustado del nuevo cliente en el campo
product_bought_by. UsaremosfindAndModify comando para esta funcionalidad porque
busca y actualiza el documento al mismo tiempo.

>[Link]({
query:{_id:2,product_available:{$gt:0}},
update:{
$inc:{product_available:-1},
$push:{product_bought_by:{customer:"rob",date:"9-Jan-2014"}}
}
})

Nuestro enfoque de documento incrustado y el uso de la consulta findAndModify asegura

que la información de compra del producto se actualice solo si el producto está disponible.
Y toda esta transacción, al estar en la misma consulta, es atómica.
En contraste con esto, considere el escenario en el que podemos haber mantenido la
disponibilidad del producto y la información sobre quién compró el producto, por separado.
En este caso, primero verificaremos si el producto está disponible mediante la primera
consulta. Luego en la segunda consulta actualizaremos la información de compra. Sin
embargo, es posible que entre las ejecuciones de estas dos consultas, algún otro usuario
haya comprado el producto y ya no esté disponible. Sin saber esto, nuestra segunda
consulta actualizará la información de compra en función del resultado de nuestra primera
consulta. Esto hará que la base de datos sea inconsistente porque hemos vendido un
producto que no está disponible.

MongoDB - Indexación avanzada

hemos insertado el siguiente documento en la colección de usuarios nombrados como se
muestra a continuación:

[Link](
{
"address": {
"city": "Los Angeles",
"state": "California",
"pincode": "123"
},
"tags": [
"music",
"cricket",
"blogs"
 ],
"name": "Tom Benzamin"
}
)

El documento anterior contiene un address sub-document y un tags array.

Campos de matriz de indexación

Supongamos que queremos buscar documentos de usuario en función de las etiquetas del
usuario. Para esto, crearemos un índice en la matriz de etiquetas en la colección.
La creación de un índice en una matriz a su vez crea entradas de índice independientes
para cada uno de sus campos. Entonces, en nuestro caso, cuando creamos un índice en
una matriz de etiquetas, se crearán índices separados para sus valores música, cricket y
blogs.
Para crear un índice en una matriz de etiquetas, use el siguiente código:

>[Link]({"tags":1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 2,
"numIndexesAfter" : 3,
"ok" : 1
}
>

Después de crear el índice, podemos buscar en el campo de etiquetas de la colección de

esta manera:

> [Link]({tags:"cricket"}).pretty()
{
"_id" : ObjectId("5dd7c927f1dd4583e7103fdf"),
"address" : {
"city" : "Los Angeles",
"state" : "California",
"pincode" : "123"
},
"tags" : [
"music",
"cricket",
"blogs"
],
 "name" : "Tom Benzamin"
}

Para verificar que se utiliza la indexación adecuada, utilice lo siguiente explain comando -

>[Link]({tags:"cricket"}).explain()

Esto le da el siguiente resultado:

{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "[Link]",
"indexFilterSet" : false,
"parsedQuery" : {
"tags" : {
"$eq" : "cricket"
}
},
"queryHash" : "9D3B61A7",
"planCacheKey" : "04C9997B",
"winningPlan" : {
"stage" : "FETCH",
"inputStage" : {
"stage" : "IXSCAN",
"keyPattern" : {
"tags" : 1
},
"indexName" : "tags_1",
"isMultiKey" : false,
"multiKeyPaths" : {
"tags" : [ ]
},
"isUnique" : false,
"isSparse" : false,
"isPartial" : false,
"indexVersion" : 2,
"direction" : "forward",
"indexBounds" : {
 "tags" : [
"[\"cricket\", \"cricket\"]
"
]
}
}
},
"rejectedPlans" : [ ]
},
"serverInfo" : {
"host" : "Krishna",
"port" : 27017,
"version" : "4.2.1",
"gitVersion" : "edf6d45851c0b9ee15548f0f847df141764a317e"
},
"ok" : 1
}
>

El comando anterior resultó en "cursor": "BtreeCursor tags_1" que confirma que se utiliza
la indexación adecuada.

Indexación de campos de subdocumentos

Suponga que queremos buscar documentos basados en campos de ciudad, estado y
código PIN. Dado que todos estos campos son parte del campo del subdocumento de
dirección, crearemos un índice en todos los campos del subdocumento.
Para crear un índice en los tres campos del subdocumento, use el siguiente código:

>[Link]({"[Link]":1,"[Link]":1,"[Link]":1
})
{
"numIndexesBefore" : 4,
"numIndexesAfter" : 4,
"note" : "all indexes already exist",
"ok" : 1
}
>

Una vez creado el índice, podemos buscar cualquiera de los campos del subdocumento
utilizando este índice de la siguiente manera:
> [Link]({"[Link]":"Los Angeles"}).pretty()
{
"_id" : ObjectId("5dd7c927f1dd4583e7103fdf"),
"address" : {
"city" : "Los Angeles",
"state" : "California",
"pincode" : "123"
},
"tags" : [
"music",
"cricket",
"blogs"
],
"name" : "Tom Benzamin"
}

Recuerde que la expresión de la consulta debe seguir el orden del índice especificado.
Entonces, el índice creado anteriormente admitiría las siguientes consultas:

>[Link]({"[Link]":"Los Angeles","[Link]":"California"}).p
retty()
{
"_id" : ObjectId("5dd7c927f1dd4583e7103fdf"),
"address" : {
"city" : "Los Angeles",
"state" : "California",
"pincode" : "123"
},
"tags" : [
"music",
"cricket",
"blogs"
],
"name" : "Tom Benzamin"
}