9 tipos de operadores de Mongodb que necesita saber

Publicado: 2022-09-09

En cualquier negocio, los datos son su mayor activo. Al analizar los datos, puede tomar decisiones sobre las tendencias de los clientes y la predicción del comportamiento. Esto impulsa la rentabilidad del negocio y la toma de decisiones efectiva.

Sin un software de base de datos, una tarea simple como encontrar el promedio de todos los valores en un sistema lleno de registros sería tediosa. Afortunadamente, las bases de datos han hecho que el análisis de datos sea más fácil y rápido con funciones y operadores.

Este artículo arrojará algo de luz sobre los operadores utilizados en el software de base de datos MongoDB.

¿Qué son los operadores de MongoDB?

MongoDB es un software de base de datos NoSQL que gestiona información orientada a documentos.

Una de las características clave de MongoDB es su velocidad. Para devolver consultas más rápido, MongoDB puede usar operadores para realizar funciones específicas.

Los operadores son símbolos especiales que ayudan a los compiladores a realizar tareas matemáticas o lógicas. MongoDB ofrece varios tipos de operadores para interactuar con la base de datos.

Tipos de operadores de MongoDB

Hay nueve tipos de operadores, cada uno nombrado por su función. Por ejemplo, los operadores lógicos usan operaciones lógicas. Para ejecutarlos, debe usar una palabra clave específica y seguir la sintaxis. Sin embargo, ¡son bastante fáciles de seguir!

Al final del artículo, podrá aprender los conceptos básicos de cada operador y sus funciones.

Operadores logicos

Los operadores lógicos se utilizan a menudo para filtrar datos en función de las condiciones dadas. También permiten la evaluación de muchas condiciones, que discutiremos con más detalle.

A continuación se muestran algunos operadores lógicos que puede utilizar:

$y

Una condición "y" realiza una operación lógica "y" en una matriz de dos o más expresiones. Selecciona los documentos donde se cumplen todas las condiciones de las expresiones.

Esta es la sintaxis estándar para la expresión $and :

 { $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } Por ejemplo, si queremos seleccionar documentos donde el precio es $10 y la cantidad es menor a 15, podemos ingresar la siguiente consulta:
 db.inventory.find( { $and: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )

$o

Una condición "o" realiza una operación lógica "o" en una matriz de dos o más expresiones. Selecciona los documentos donde al menos una de las expresiones es verdadera.

Esta es la sintaxis estándar para la expresión $or :

 { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }.

Por ejemplo, si queremos seleccionar documentos donde el precio es $10 o la cantidad es menor a 15, podemos ingresar la siguiente consulta:

 db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )

No tenemos que limitar la expresión a dos criterios, podemos agregar más. Por ejemplo, la siguiente consulta selecciona aquellos documentos donde el precio es igual a $10, la cantidad es inferior a 15 o la etiqueta es estacionaria:

 db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 }, { tag: stationary }] } )

Al ejecutar estas cláusulas, MongoDB realiza un escaneo de colección o un escaneo de índice. Si todos los índices admiten las cláusulas, entonces MongoDB usa índices para verificar una expresión $or . De lo contrario, utiliza un escaneo de colección en su lugar.

Pero si desea probar los criterios en el mismo campo, es posible que desee utilizar el operador $in lugar del operador $or . Por ejemplo, si desea una colección de documentos donde la cantidad sea 10 o 20, es posible que deba ejecutar la siguiente consulta $in su lugar:

 db.inventory.find ( { quantity: { $in: [20, 50] } } )

Cubriremos más sobre el operador $in más adelante.

$ni

Este operador realiza una operación lógica "ni" en una matriz utilizando una o más expresiones. A continuación, selecciona los documentos que fallan en las expresiones de consulta. En términos más simples, hace lo contrario de la condición $or .

Esta es la sintaxis general:

 { $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }

Consideremos la siguiente consulta:

 db.inventory.find( { $nor: [ { price: 3.99 }, { sale: true } ] } )

Esta consulta selecciona los documentos que contienen:

  • un valor de campo de precio no igual a $3.99 y un valor de venta no igual a verdadero; o
  • un valor de campo de precio no igual a $3.99 y un campo de venta vacío o ausente; o
  • sin campo de precio, y un campo de venta no igual a verdadero; o
  • ni el campo de precio ni el campo de venta están poblados o presentes.

$no

Este operador realiza una operación lógica "no" en una matriz para la expresión especificada. A continuación, selecciona los documentos que no coinciden con las expresiones de consulta. Esto incluye los documentos que no contienen el campo.

Esta es la sintaxis general:

 { field: { $not: { <operator-expression> } } }

Por ejemplo, tome la siguiente consulta:

 db.inventory.find( { price: { $not: { $lt: 3.99 } } } )

Esta consulta seleccionaría aquellos documentos que contengan:

  • un campo de precio cuyo valor es mayor o igual a $3.99; y
  • un campo de precio está vacío o no existe.

Operadores de comparación

Los operadores de comparación se pueden utilizar para comparar valores en uno o más documentos.

A continuación se muestra un código de muestra de una recopilación de inventario simple para una tienda de supermercado:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] }, { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] }, { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }, { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

Usaremos este ejemplo mientras detallamos cada operador de comparación a continuación.

Igual a ($eq)

Este operador coincide con valores que son iguales al valor dado:

 { <field>: { $eq: <value> } }

Por ejemplo, si queremos recuperar un documento específico de la colección de inventario que tenga el valor de cantidad exacto "20", ingresaríamos el siguiente comando:

 db.inventory.find( { qty: { $eq: 20 } } )

La consulta devolvería lo siguiente:

 { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Mayor que ($gt)

Este operador coincide si los valores son mayores que el valor dado:

 { field: { $gt: value } }

En este ejemplo, recuperamos los documentos donde la cantidad es mayor a 15:

 db.inventory.find({"qty": { $gt: 15}})

La consulta devolvería lo siguiente:

 { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Menos de ($lt)

Este operador coincide si los valores son menores que el valor proporcionado:

 { field: { $lt: value } }

Busquemos los documentos con una cantidad inferior a 25:

 db.inventory.find({"qty": { $lt: 25}})

La consulta devolvería lo siguiente:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

Mayor o igual a ($gte)

Este operador coincide cuando los valores son mayores o iguales al valor dado:

 { field: { $gte: value } }

En este ejemplo, recuperamos los documentos donde la cantidad es mayor o igual a 25:

 db.inventory.find({"qty": { $gte: 25}})

Esta consulta devolvería lo siguiente:

 { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }

Menor o igual a ($lte)

Este operador coincide solo si los valores son menores o iguales al valor dado:

 { field: { $lte: value } }

Encontremos los documentos con una cantidad menor o igual a 25.

 db.inventory.find({"qty": { $lte: 25}})

Podemos esperar que esta consulta devuelva lo siguiente:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

en ($in)

Este operador devuelve los documentos que coinciden con los valores especificados:

 { field: { $in: [<value1>, <value2>, ... <valueN> ] } }

El valor de un campo es igual a cualquier valor en la matriz especificada. Para recuperar los documentos con valores "30" y "15" en la colección de inventario, por ejemplo, haría lo siguiente:

 db.collection.find({ "qty": { $in: [30, 15]}})

La salida sería:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }
La consulta se ejecuta en MongoDB Shell.

No en ($nin)

Este operador devuelve los documentos que no coinciden con los valores dados. Esta es la sintaxis básica del operador $nin :

 { field: { $nin: [ <value1>, <value2> ... <valueN> ]

$nin selecciona los documentos donde:

  • el valor del campo no está en la matriz especificada; o
  • el campo no existe.

Si el campo contiene matrices, seleccionará matrices donde no esté presente ningún elemento especificado en la sección de valor. Por ejemplo, queremos seleccionar aquellos documentos donde la cantidad no es ni 20 ni 15.

Además, también hace coincidir documentos que no tienen un campo de cantidad:

 db.collection.find({ "qty": { $nin: [ 20, 15 ]}}, {_id: 0})

La salida sería:

 { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

No igual ($ne)

El operador $ne devuelve los documentos donde el valor especificado no es igual:

 { $ne: value } }

Por ejemplo, digamos que queremos seleccionar todos los documentos donde la cantidad no es igual a 20:

 db.inventory.find( { qty: { $ne: 20 } } )

La salida sería:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

Del resultado anterior, podemos ver que la consulta seleccionará documentos que no tienen un campo de cantidad.

Operadores de elementos

Los operadores de consulta de elementos pueden identificar documentos utilizando los campos del documento. Los operadores de elementos consisten en $exist y $type .

$existe

Este operador coincide con documentos que tienen un campo específico. Este operador tiene un valor booleano que puede ser true o false .

Si se especifica como true , coincide con los documentos que contienen ese campo, incluidos los documentos donde el valor del campo es nulo. Si <booleano> es false , la consulta devuelve solo los documentos que no contienen el campo.

Aquí está la sintaxis estándar:

 { field: { $exists: <boolean> } }

Tomemos un ejemplo en el que tenemos una colección de datos para una matriz llamada "bolsadecanicas", donde cada bolsa contiene canicas de diferentes colores:

 { red: 5, green: 5, blue: null } { red: 3, green: null, blue: 8 } { red: null, green: 3, blue: 9 } { red: 1, green: 2, blue: 3 } { red: 2, blue: 5 } { red: 3, green: 2 } { red: 4 } { green: 2, blue: 4 } { green: 2 } { blue: 6 }

Digamos que queremos una consulta que devuelva solo aquellas bolsas donde existen las canicas rojas. Esto significa que tendríamos que ingresar el valor booleano como true . Vamos a ver:

 db.bagofmarbles.find( { red: { $exists: true } } )

Los resultados consistirían en aquellos documentos que contuvieran el campo “rojo”, aunque el valor fuera null . Sin embargo, no consistiría en los documentos donde el campo “rojo” ni siquiera existiera:

 { red: 5, green: 5, blue: null } { red: 3, green: null, blue: 8 } { red: null, green: 3, blue: 9 } { red: 1, green: 2, blue: 3 } { red: 2, blue: 5 } { red: 3, green: 2 } { red: 4 }

Si solo quisiéramos esas bolsas donde las canicas rojas ni siquiera existen como campo, podemos ingresar la siguiente consulta:

 db.bagofmarbles.find( { red: { $exists: false} }

Los resultados consistirían en aquellos documentos que no contengan el campo “rojo”:

 { green: 2, blue: 4 } { green: 2 } { blue: 6 }

$tipo

Este operador hace coincidir los documentos según el tipo de campo especificado. Esto es útil cuando tiene datos muy desestructurados o cuando los tipos de datos no son predecibles. Estos tipos de campo son tipos BSON especificados y se pueden definir por número de tipo o alias.

Esta es la sintaxis general para $type :

 { field: { $type: <BSON type> } }

Digamos que tenemos una libreta de direcciones que contiene los siguientes documentos:

 db={ addressBook: [ { "_id": 1, address: "2100 Jupiter Spot", zipCode: "9036325" }, { "_id": 2, address: "25 Moon Place", zipCode: 26237 }, { "_id": 3, address: "2324 Neptune Ring", zipCode: NumberLong(77622222) }, { "_id": 4, address: "33 Saturns Moon", zipCode: NumberInt(117) }, { "_id": 5, address: "1044 Venus Lane", zipCode: [ "99883637232", "73488976234" ] } ] }

Al observar los documentos anteriores, el código postal tiene diferentes tipos de datos. Esto incluye valores largos, dobles, enteros y de cadena.

Si solo queremos aquellos documentos que tienen un tipo de datos específico como el código postal, tomemos una cadena para esta instancia, tendríamos que ingresar la siguiente consulta en el compilador:

 db.addressBook.find({ "zipCode": { $type: "string" } })

Esto devolvería los siguientes documentos:

 [ { "_id": 1, "address": "2100 Jupiter Spot", "zipCode": "9036325" }, { "_id": 5, "address": "1044 Venus Lane", "zipCode": [ "99883637232", "73488976234" ] } ]
La consulta anterior se ejecuta en un MongoDB Shell.

Además, hay un tipo de "número", que incluye todos los valores largos, enteros o dobles como una matriz que contiene un elemento de los tipos especificados:

 db.addressBook.find( { "zipCode" : { $type : "number" } } )

Producción:

 [ { "_id": 2, address: "25 Moon Place", zipCode: 26237 }, { "_id": 3, address: "2324 Neptune Ring", zipCode: NumberLong(77622222) }, { "_id": 4, address: "33 Saturns Moon", zipCode: NumberInt(117) } ]

Si los documentos tienen un tipo de campo de matriz, el operador $type devuelve los documentos en los que al menos un elemento de la matriz coincide con el tipo pasado al operador.

Operadores de matrices

MongoDB también consta de operadores de matriz, para consultar documentos que contienen matrices.

Hay tres operadores principales: $all , $elemMatch y $size . Discutiremos cada uno en detalle a continuación.

$ todo

El operador $all elige los documentos en los que el valor de un campo es una matriz que contiene los elementos especificados:

 { : { $all: [ <value1> , <value2> ... ] } }

Por ejemplo, supongamos que tenemos una colección de documentos para una tienda de ropa, con lo siguiente en inventario.

 { _id: ObjectId("5234cc89687ea597eabee675"), code: "shirt", tags: [ "sale", "shirt", "button", "y2k", "casual" ], qty: [ { size: "S", num: 10, color: "blue" }, { size: "M", num: 45, color: "blue" }, { size: "L", num: 100, color: "green" } ] }, { _id: ObjectId("5234cc8a687ea597eabee676"), code: "pant", tags: [ "y2k", "trendy", "shine" ], qty: [ { size: "6", num: 100, color: "green" }, { size: "6", num: 50, color: "blue" }, { size: "8", num: 100, color: "brown" } ] }, { _id: ObjectId("5234ccb7687ea597eabee677"), code: "pant2", tags: [ "trendy", "shine" ], qty: [ { size: "S", num: 10, color: "blue" }, { size: "M", num: 100, color: "blue" }, { size: "L", num: 100, color: "green" } ] }, { _id: ObjectId("52350353b2eff1353b349de9"), code: "shirt2", tags: [ "y2k", "trendy" ], qty: [ { size: "M", num: 100, color: "green" } ] }

Nos gustaría recuperar cualquier documento (en este caso, la ropa) del inventario que esté vinculado con las etiquetas "trendy" y "y2k". La siguiente consulta usa el operador $all donde el valor del campo de etiquetas es una matriz cuyos elementos incluyen "y2k" y "trendy":

 db.inventory.find( { tags: { $all: [ "y2k", "trendy" ] } } )

La consulta anterior devuelve lo siguiente:

 { _id: ObjectId("5234cc8a687ea597eabee676"), code: "pant", tags: [ "y2k", "trendy", "shine" ], qty: [ { size: "6", num: 100, color: "green" }, { size: "6", num: 50, color: "blue" }, { size: "8", num: 100, color: "brown" } ] } { _id: ObjectId("52350353b2eff1353b349de9"), code: "shirt2", tags: [ "y2k", "trendy" ], qty: [ { size: "M", num: 100, color: "green" } ] }
La consulta anterior se ejecuta en un MongoDB Shell.

Del ejemplo anterior, también encontramos que el operador $all simplemente realiza la misma función que la operación $and .

Alternativamente, podríamos usar la siguiente consulta que daría un resultado similar al anterior:

 db.collection.find({ $and: [ { tags: "y2k" }, { tags: "trendy" } ] })
La consulta anterior se ejecuta en un shell de MongoDB.

$partidoelemento

El operador $elemMatch hace coincidir documentos que contienen un campo de matriz con al menos un elemento que coincide con todos los criterios de consulta especificados:

 { : { $elemMatch: { <query1>, <query2>, ... } } }

Si bien podemos usar operadores de comparación como $lte y $gte , si especificamos solo una única condición de consulta dentro $elemMatch y no usamos los operadores $not o $ne , se puede omitir el uso de $elemMatch ya que esencialmente estaría funcionando la misma función.

Hay algunas cosas más a tener en cuenta al usar este operador, principalmente:

  • No puede especificar una expresión $where en una operación $elemMatch .
  • No puede especificar una expresión de consulta de $text en una operación $elemMatch .

Por ejemplo, tenemos los siguientes documentos en la colección de resultados de los estudiantes:

 { _id: 1, results: [ 92, 89, 98 ] } { _id: 2, results: [ 85, 99, 99 ] }

La siguiente consulta coincide solo con aquellos documentos en los que la matriz de resultados contiene al menos un elemento que es mayor o igual a 90 y menor que 95:

 db.studentresults.find( { results: { $elemMatch: { $gte: 90, $lt: 95 } } })

Nuestra consulta devuelve el siguiente documento, ya que el elemento 92 es mayor o igual que 90 y menor que 95:

 { "_id" : 1, "results" :[ 92, 89, 98 ] }

$tamaño

El operador $size devuelve aquellos documentos donde el tamaño de la matriz coincide con la cantidad de elementos especificados en el argumento:

 { field: { $size: value } }

Aquí hay un ejemplo:

 db.collection.find( { field: { $size: 2 } });

Esto devolvería todos los documentos en la colección especificada donde el campo es una matriz con 2 elementos: { field: [ orange, apple] } y { field: [ blue, red] } , pero no { field: blue} o { field: [ raspberry, lemon, grapefruit ] } .

Sin embargo, aunque podemos ingresar el valor específico como tamaño, no podemos especificar rangos de valores como tamaño.

Operadores geoespaciales

MongoDB le permite almacenar datos geoespaciales en forma de tipos GeoJSON. GeoJSON es un formato de estándar abierto basado en la notación de objetos de JavaScript que puede representar características geográficas y admitir atributos no espaciales. Hay dos tipos de operadores geoespaciales de los que hablaremos en este artículo: especificadores de geometría y selectores de consulta.

$geometría

Este operador menciona la geometría GeoJSON para su uso con los siguientes operadores de consulta geoespacial: $geoIntersects , $geoWithin , $nearSphere y $near . $geometry aprovecha EPSG:4326 como el sistema de referencia de coordenadas (CRS) predeterminado.

Para mencionar objetos GeoJSON con el CRS predeterminado, puede aprovechar el siguiente fragmento de código para $geometry :

 $geometry: { type: "<GeoJSON object type>", coordinates: [ <coordinates> ] }

Para mencionar un polígono GeoJSON de un solo anillo con un MongoDB CRS personalizado, puede usar el siguiente fragmento (solo puede usar esto para $geoWithin y $geoIntersects ):

 $geometry: { type: "Polygon", coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } }

$polígono

El operador $polygon se puede usar para especificar un polígono para una consulta geoespacial $geoWithin en pares de coordenadas heredados. Esta consulta devolverá pares que se encuentren dentro de los límites del polígono. Sin embargo, $polygon no consultará ningún objeto GeoJSON. Para definir un polígono, debe especificar una matriz de puntos de coordenadas de la siguiente manera:

 { : { $geoWithin: { $polygon: [ [ <x1> , <y1> ], [ <x2> , <y2> ], [ <x3> , <y3> ], ... ] } } }

Aquí, el último punto está implícitamente conectado con el primero. Puedes mencionar tantos puntos o lados como quieras.

Por ejemplo, la siguiente consulta devolverá todos los documentos que tienen coordenadas que existen dentro del polígono definido por [0,0], [1,5] y [3,3]:

 db.places.find( { loc: { $geoWithin: { $polygon: [ [ 0 , 0 ], [ 1 , 5 ], [ 3 , 3 ] ] } } } )

$geoDentro

Este operador se puede usar para elegir documentos con datos geoespaciales que están completamente contenidos en una forma específica. La forma especificada puede ser un polígono múltiple GeoJSON, un polígono GeoJSON (ya sea de varios anillos o de un solo anillo) o una forma que se puede definir mediante pares de coordenadas heredados.

El operador $geoWithin aprovechará el operador $geometry para mencionar el objeto GeoJSON.

Para mencionar los polígonos o multipolígonos de GeoJSON a través del sistema de referencia de coordenadas (CRS) predeterminado, puede utilizar la sintaxis que se menciona a continuación:

 { : { $geoWithin: { $geometry: { type: <"Polygon" or "MultiPolygon"> , coordinates: [ <coordinates> ] } } } }

Para las consultas $geoWithin que mencionan las geometrías GeoJSON con áreas más grandes que un solo hemisferio, el uso del CRS predeterminado generaría consultas para las geometrías complementarias.

Para mencionar un polígono GeoJSON de un solo anillo con un MongoDB CRS personalizado, puede aprovechar el prototipo que se menciona a continuación en la expresión $geometry :

 { : { $geoWithin: { $geometry: { type: "Polygon" , coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } } } } }

El siguiente ejemplo selecciona todos los datos de ubicación que existen completamente dentro de un polígono GeoJSON, siendo el área del polígono menor que el área de un solo hemisferio:

 db.places.find( { loc: { $geoWithin: { $geometry: { type : "Polygon" , coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ] ] } } } } )

$caja

Puede usar $box para especificar un rectángulo para una consulta geoespacial $geoWithin para proporcionar documentos que se encuentran dentro de los límites del rectángulo, de acuerdo con sus datos de ubicación basados ​​en puntos. Cuando usa $geoWithin con $box , obtendrá documentos basados ​​en coordenadas de consulta. En este escenario, $geoWithin no consultará ninguna forma GeoJSON.

Para aprovechar el operador $box , debe mencionar las esquinas superior derecha e inferior izquierda del rectángulo en un objeto de matriz:

 { <location field> : { $geoWithin: { $box: [ [ <bottom left coordinates> ], [ <upper right coordinates> ] ] } } }

La consulta antes mencionada calculará la distancia utilizando geometría plana (plana). La siguiente consulta devolverá todos los documentos que están dentro de la casilla con puntos en: [0,0], [0,30], [30,0], [30,30]:

 db.places.find ( { loc: { $geoWithin: { $box: [ [ 0,0 ], [ 30,30 ] ] } } } )

$nearSphere

Puede usar $nearSphere para mencionar un punto para el cual una consulta geoespacial devuelve los documentos del más cercano al más lejano.

MongoDB usa geometría esférica para calcular las distancias para $nearSphere . Necesitará un índice geoespacial de la siguiente manera:

  1. Índice 2d para datos de ubicación descritos como pares de coordenadas heredados. Para aprovechar un índice 2d en puntos GeoJSON, debe generar el índice en el campo de coordenadas del objeto GeoJSON.
  2. Índice de 2dsphere para datos de ubicación descritos como puntos GeoJSON.

Para mencionar un punto GeoJSON, puede aprovechar la siguiente sintaxis:

 { $nearSphere: { $geometry: { type : "Point", coordinates : [ <longitude>, <latitude> ] }, $minDistance: <distance in meters>, $maxDistance: <distance in meters> } }

Aquí, $minDistance y $maxDistance son opcionales. $minDistance puede limitar los resultados a aquellos documentos que están al menos a la distancia especificada del centro. Puede usar $maxDistance para cualquier índice.

Ahora, considere una colección de "lugares" que consta de documentos con un campo de ubicación que tiene un índice de 2dsphere. El siguiente ejemplo devolvería los puntos cuya ubicación es al menos 2.000 metros y como máximo 6.000 metros desde el punto que elija, ordenados del más cercano al más lejano:

 db.places.find( { location: { $nearSphere: { $geometry: { type : "Point", coordinates : [ -43.9532, 50.32 ] }, $minDistance: 2000, $maxDistance: 6000 } } } )

$geoIntersecciones

El operador $geoIntersects le permite seleccionar documentos cuyos datos geoespaciales se cruzan con un objeto GeoJSON en particular (es decir, donde la convergencia del objeto especificado y los datos no está vacía). Aprovecha el operador $geometry para especificar el objeto GeoJSON.

Para mencionar multipolígonos o polígonos GeoJSON a través del sistema de referencia de coordenadas (CRS) predeterminado, puede usar la siguiente sintaxis:

 { <location field>: { $geoIntersects: { $geometry: { type: "<GeoJSON object type>" , coordinates: [ <coordinates> ] } } } }

La siguiente instancia usará $geoIntersects para seleccionar todos los datos de ubicación que se cruzan con el polígono descrito por la matriz de coordenadas:

 db.places.find( { loc: { $geoIntersects: { $geometry: { type: "Polygon" , coordinates: [ [ [ 0, 0 ], [ 2, 6 ], [ 4, 1 ], [ 0, 0 ] ] ] } } } } )

$centro

El operador $center menciona un círculo para una consulta $geoWithin que devuelve pares de coordenadas heredados que están dentro de los límites del círculo.

$center no devuelve objetos GeoJSON. Para aprovechar el operador $center , debe especificar una matriz que contenga:

  1. El radio del círculo, medido en las unidades utilizadas por el sistema de coordenadas.
  2. Las coordenadas de cuadrícula del punto central del círculo.
 { <location field> : { $geoWithin: { $center: [ [ <x> , <y> ] , <radius> ] } } }

El ejemplo mencionado a continuación devolverá todos los documentos que tienen coordenadas que se pueden encontrar dentro del círculo centrado en [2,3] y con un radio de 40:

 db.places.find( { loc: { $geoWithin: { $center: [ [2, 3], 40 ] } } } )

Operadores de proyección

Puede utilizar operadores de proyección para mencionar los campos devueltos por una operación. Los operadores de proyección de MongoDB permiten usar la función find() con argumentos de filtrado de datos. Esto ayuda a los usuarios a extraer solo los campos de datos requeridos de un documento. Por lo tanto, le permite proyectar datos transparentes y concisos sin afectar el rendimiento general de la base de datos.

$elemMatch (proyección)

El operador $elemMatch es responsable de limitar el contenido de un campo de los resultados de la consulta para que solo contenga el primer elemento que coincida con la condición $elemMatch .

Aquí hay algunas cosas que debe tener en cuenta antes de usar $elemMatch :

  • A partir de MongoDB 4.4, independientemente del orden de los campos en el documento, la proyección $elemMatch de un campo existente devuelve el campo después de la inclusión de otros campos existentes.
  • Tanto los $elemMatch como $ representan el primer elemento coincidente de una matriz en función de una condición específica. El operador $ proyectaría el primer elemento de matriz coincidente de cada documento de una colección en función de alguna condición de la declaración de consulta, mientras que el operador de proyección $elemMatch toma un argumento de condición explícito. Esto le permite proyectar en función de una condición que no está presente en la consulta, o si necesita proyectar en función de varios campos en los documentos incrustados de la matriz.

También debe tener en cuenta las siguientes restricciones antes de usar el operador $elemMatch en sus datos:

  • No puede mencionar una expresión de consulta de $text dentro de un operador $elemMatch .
  • Las operaciones db.collection.find() en las vistas no admiten el operador de proyección $elemMatch .

El siguiente ejemplo en el operador de proyección $elemMatch asume una colección de schools con los siguientes documentos:

 { _id: 1, zipcode: "63108", students: [ { name: "mark", school: 102, age: 9 }, { name: "geoff", school: 101, age: 13 }, { name: "frank", school: 104, age: 12 } ] } { _id: 2, zipcode: "63110", students: [ { name: "harry", school: 103, age: 14 }, { name: "george", school: 103, age: 7 }, ] } { _id: 3, zipcode: "63108", students: [ { name: "harry", school: 103, age: 14 }, { name: "george", school: 103, age: 7 }, ] } { _id: 4, zipcode: "63110", students: [ { name: "jim", school: 103, age: 9 }, { name: "michael", school: 103, age: 12 }, ] }

En este caso, la operación find() consulta todos los documentos donde el valor del campo de código postal es 63110. La proyección $elemMatch devolvería solo el primer elemento coincidente de la matriz de students donde el campo de la school tiene un valor de 103:

 db.schools.find( { zipcode: "63110" }, { students: { $elemMatch: { school: 103 } } } ) This is what the result would look like: { "_id" : 2, "students" : [ { "name" : "harry", "school" : 103, "age" : 14 } ] } { "_id" : 4, "students" : [ { "name" : "jim", "school" : 103, "age" : 9 } ] }

$segmento (proyección)

El operador de proyección $slice se puede usar para especificar la cantidad de elementos en una matriz para devolver en el resultado de la consulta:

 db.collection.find( <query> , { <arrayField> : { $slice: <number> } } );

También se puede expresar de esta manera:

 db.collection.find( <query> , { <arrayField> : { $slice: [ <number> , <number> ] } } );

Para demostrar lo mismo, puede crear una colección de tweets de ejemplo con los siguientes documentos:

 db.posts.insertMany([ { _id: 1, title: "Nuts are not blueberries.", comments: [ { comment: "0. true" }, { comment: "1. blueberries aren't nuts."} ] }, { _id: 2, title: "Coffee please.", comments: [ { comment: "0. Indubitably" }, { comment: "1. Cuppa tea please" }, { comment: "2. frappucino" }, { comment: "3. Mocha latte" }, { comment: "4. whatever" } ] } ])

La siguiente operación usaría el operador de proyección $slice en la matriz de tweets para devolver la matriz con sus dos primeros elementos. Si una matriz contiene menos de dos elementos, se devuelven todos los elementos de la matriz:

 db.posts.find( {}, { comments: { $slice: 2 } } )

Esa operación devolvería los siguientes documentos:

 { "_id" : 1, "title" : "Nuts are not blueberries.", "comments" : [ { "comment" : "0. true" }, { "comment" : "1. blueberries aren't nuts." } ] } { "_id" : 2, "title" : "Coffee please.", "comments" : [ { "comment" : "0. Indubitably" }, { "comment" : "1. Cuppa tea please" } ] }

$ (proyección)

El operador posicional $ limita el contenido de una matriz para devolver el primer elemento que coincida con la condición de consulta de esa matriz. Puede usar $ en el documento de proyección del método find() o el método findOne() cuando solo necesita un elemento de matriz en particular en los documentos elegidos.

Así es como se ve la sintaxis del operador $ :

 db.collection.find( { <array>: <condition> ... }, { "<array>.$": 1 } ) db.collection.find( { <array.field>: <condition> ...}, { "<array>.$": 1 } )

En este ejemplo, la colección de students consta de los siguientes documentos:

 { "_id" : 1, "semester" : 2, "grades" : [ 75, 67, 93 ] } { "_id" : 2, "semester" : 2, "grades" : [ 60, 68, 72 ] } { "_id" : 3, "semester" : 2, "grades" : [ 95, 82, 67 ] } { "_id" : 4, "semester" : 3, "grades" : [ 89, 95, 70 ] } { "_id" : 5, "semester" : 3, "grades" : [ 68, 98, 82 ] } { "_id" : 6, "semester" : 3, "grades" : [ 65, 70, 76 ] }

En la siguiente consulta, la proyección { "grades.$": 1 } devuelve solo el primer elemento mayor o igual a 89 para el campo de grades :

 db.students.find( { semester: 2, grades: { $gte: 89 } }, { "grades.$": 1 } )

Esta operación devuelve los siguientes documentos:

 {"_id": 3, "grades": [95] }

Operadores de evaluación

Puede aprovechar los operadores de evaluación de MongoDB para medir la estructura de datos general o el campo individual dentro de un documento.

Veamos algunos operadores comunes de evaluación de MongoDB.

$ mod

Puede usar este operador para hacer coincidir documentos en los que el valor de un campo específico es igual al resto después de dividirse por un valor específico:

 { field: { $mod: [ divisor, remainder ] } }

Supongamos que tiene una tabla de autos pertenecientes a diferentes marcas que posee en su sala de exposición. La siguiente consulta le daría todas las marcas de automóviles cuyos números de stock son múltiplos de 250.

 db.cars.find ( { qty: { $mod: [ 250,0 ] } } )

$jsonEsquema

El $jsonSchema le permite hacer coincidir los documentos que coinciden con el esquema JSON especificado. La implementación de MongoDB del esquema JSON incluye la adición de la palabra clave bsonType , que le permite usar todos los tipos BSON dentro del operador $jsonSchema .

bsonType puede aceptar los mismos alias de cadena que usaría para el operador de type . Así es como se vería la sintaxis de $jsonSchema :

 { $jsonSchema: <JSON Schema object> }

Aquí, el objeto de esquema JSON tiene un formato basado en el borrador 4 del estándar de esquema JSON:

 { <keyword1>: <value1>, ... }

Aquí hay un ejemplo para demostrar cómo funciona $jsonSchema :

 { $jsonSchema: { required: [ "name", "major", "gpa", "address" ], properties: { name: { bsonType: "string", description: "must be a string and is required" }, address: { bsonType: "object", required: [ "zipcode" ], properties: { "street": { bsonType: "string" }, "zipcode": { bsonType: "string" } } } } } }

También puede usar $jsonSchema en un validador de documentos para aplicar el esquema especificado en las operaciones de actualización e inserción:

 db.createCollection(<collection> , { validator: { $jsonSchema: <schema> } } ) db.runCommand( { collMod: <collection>, validator:{ $jsonSchema: <schema> } } )

Tenga en cuenta que hay varias cosas que no son compatibles con el operador $jsonSchema :

  1. El tipo entero. Debe aprovechar el tipo BSON long o int con la palabra clave bsonType.
  2. Palabras clave desconocidas.
  3. Vinculación de propiedades e hipermedia del esquema JSON, junto con el uso de referencias JSON y punteros JSON.

$texto

El operador $text buscaría un texto dentro del contenido del campo especificado, indexado con un índice de texto:

 { $text: { $search: <string>, $language: <string>, $caseSensitive: <boolean>, $diacriticSensitive: <boolean> } }

En este caso, el siguiente fragmento de código filtrará la tabla para filtrar cualquier automóvil que tenga el texto "Porsche" en ellos:

 db.cars.find( { $text: { $search: "Porsche" } } )

$ expresión regular

El operador $regex ofrece capacidades de expresión regular para patrones de coincidencia de cadenas en las consultas. MongoDB aprovecha las expresiones regulares que son compatibles con Perl:

 {<field> : /pattern/ <options>}

El siguiente ejemplo ayudaría a filtrar todos los autos que tienen la cadena "$78900" presente en ellos:

 db.cars.find( { price: { $regex: /$78900/ } } )

$expr

El operador $expr le permite aprovechar las expresiones de agregación dentro del lenguaje de consulta:

 { $expr: { <expression> } }

También puede usar $expr para crear expresiones de consulta que comparen campos del mismo documento en una etapa de $match . If the $match stage happens to be the part of a $lookup stage, $expr can compare fields with the help of let variables.

$where

You can leverage the $where operator to either pass a string containing a full JavaScript function or a JavaScript expression to the query system. The $where operator provides greater flexibility but needs the database to process the JavaScript function or expression for every document in the collection. You can reference this document in the JavaScript function or expression by using either obj or this .

Here's an example of the syntax:

 { $where: <string|JavaScript Code> }

There are a few key considerations to keep in mind before we dive into an example while using the $where operator:

  • You should only use the $where query operator to top-level documents. The $where query operator won't function in a nested document, like in a $elemMatch query.
  • Generally, you should use $where only when you cannot express your query via another operator. If you have to use $where , make sure you include at least one other standard query operator to filter the result set. Using $where independently requires a collection scan for proper execution.

Here's an example to illustrate this:

 db.cars.find( { $where: function() { return (hex_md5(this.name)== "9a43e617b50cd379dca1bc6e2a8") } } );

Bitwise Operators

Bitwise operators return data based on bit position conditions. Simply put, they are used to match numeric or binary values in which any bit from a set of bit positions has a value of 1 or 0.

$bitsAllSet

This operator will match all the documents where all of the bit positions provided by the query are set (ie 1) in the field:

{ <field> : { $bitsAllSet: <numeric bitmask> } }
 { <field> : { $bitsAllSet: < BinData bitmask> } }
 { <field> : { $bitsAllSet: [ <position1> , <position2> , ... ] } }

El valor del campo debe ser una instancia de BinData o un valor numérico para que $bitsAllSet coincida con el documento actual.

En el siguiente caso, estamos aprovechando una colección con los siguientes documentos:

 db.collection.save({ _id: 1, a: 54, binaryValueofA: "00110110" }) db.collection.save({ _id: 2, a: 20, binaryValueofA: "00010100" }) db.collection.save({ _id: 3, a: 20.0, binaryValueofA: "00010100" }) db.collection.save({ _id: 4, a: BinData(0, "Zg=="), binaryValueofA: "01100110" })

La consulta que se menciona a continuación utilizará el operador $bitsAllSet para probar si el campo a tiene bits establecidos en la posición 1 y la posición 5, donde el bit menos significativo estaría en la posición 0:

 db.collection.find( { a: { $bitsAllSet: [ 1, 5 ] } }

Esta consulta coincidiría con los siguientes documentos:

 { "_id" : 1, "a" : 54, "binaryValueofA" : "00110110" } { "_id" : 4, "a" : BinData(0,"Zg=="), "binaryValueofA" : "01100110" }

$bitsTodoBorrar

El operador $bitsAllClear hará coincidir los documentos en los que todas las posiciones de bits proporcionadas por la consulta son claras o 0 :

 { <field> : { $bitsAllClear: <numeric bitmask> } }
 { <field> : { $bitsAllClear: < BinData bitmask> } }
 { <field> : { $bitsAllClear: [ <position1> , <position2> , ... ] } }

Usaremos el ejemplo usado para $bitsAllSet aquí para demostrar el uso de $bitsAllClear . La siguiente consulta usaría este operador para verificar si el campo a tiene los bits libres en las posiciones 1 y 5:

 db.collection.find( { a: { $bitsAllClear: [ 1, 5 ] } } )

Esta consulta coincidiría con los siguientes documentos:

 { "_id" : 2, "a" : 20, "binaryValueofA" : "00010100" } { "_id" : 3, "a" : 20, "binaryValueofA" : "00010100" }

Metaoperadores

Hay varios modificadores de consultas que le permiten modificar el comportamiento o el resultado de una consulta en MongoDB. Las interfaces del controlador pueden proporcionar métodos de cursor que los ajusten para su uso.

$pista

MongoDB dejó de usar $hint desde v3.2. Sin embargo, es posible que este operador aún esté disponible para controladores MongoDB como Go, Java, Scala, Ruby, Swift, etc. Puede forzar al optimizador de consultas a aprovechar un índice específico para completar la consulta, que luego se puede mencionar por documento o por nombre de índice.

También puede usar el operador $hint para probar las estrategias de indexación y el rendimiento de las consultas. Por ejemplo, tome la siguiente operación:

 db.users.find().hint( { age: 1 } )

Esta operación devolvería todos los documentos dentro de la colección llamados users aprovechando el índice en el campo de age .

También puede mencionar una pista utilizando cualquiera de los siguientes formularios:

 db.users.find()._addSpecial( "$hint", { age : 1 } ) db.users.find( { $query: {}, $hint: { age : 1 } } )

Si existe un filtro de índice para la forma de consulta, MongoDB simplemente ignoraría la $hint .

$comentario

El operador $comment le permite adjuntar un comentario a una consulta en cualquier contexto en el que pueda aparecer $query . Dado que los comentarios se propagan al registro del perfil, agregar un comentario puede facilitar la interpretación y el seguimiento de su perfil.

Puede aprovechar $comment de una de estas tres maneras:

 db.collection.find( { <query> } )._addSpecial( "$comment", <comment> ) db.collection.find( { <query> } ).comment( <comment> ) db.collection.find( { $query: { <query> }, $comment: <comment> } )

Si desea adjuntar comentarios a expresiones de consulta en otros contextos, como con db.collection.update() , aproveche el operador de consulta $comment en lugar del metaoperador.

$máx.

Puede mencionar un valor $max para especificar el límite superior exclusivo de un índice en particular para restringir los resultados de find() . Este operador especificará el límite superior para todas las claves de un orden específico en el índice.

Mongosh le ofrece el siguiente método contenedor max() :

 db.collection.find( { <query> } ).max( { field1: <max value> , ... fieldN: <max valueN> } )

También puede mencionar $max con las siguientes dos formas:

 db.collection.find( { <query> } )._addSpecial( "$max", { field1: <max value1> , ... fieldN: <max valueN> } ) db.collection.find( { $query: { <query> }, $max: { field1: <max value1> , ... fieldN: <max valueN> } } )

Por ejemplo, si desea especificar el límite superior exclusivo, tenga en cuenta las siguientes operaciones en una colección denominada colección que contiene un índice { age: 1 } :

 db.collection.find( { <query> } ).max( { age: 100 } ).hint( { age: 1 } )

Esta operación limitará la consulta a aquellos documentos en los que la antigüedad del campo sea inferior a 100 y forzará un plan de consulta que analizará el índice { age: 1 } desde minKey hasta 100.

$explicar

Este operador le dará información sobre el plan de consulta. Devuelve un documento que describe los índices y procesos utilizados para devolver la consulta. Esto puede ser útil cuando se intenta optimizar una consulta.

Puede mencionar el operador $explain en cualquiera de las siguientes formas:

 db.collection.find()._addSpecial( "$explain", 1 ) db.collection.find( { $query: {}, $explain: 1 } )

Mejores prácticas para operadores de MongoDB

En esta sección, veremos algunas de las mejores prácticas al usar estos operadores de MongoDB.

Incrustación y referencia

La incrustación es una extensión natural del modelado de datos. Le permite evitar las uniones de aplicaciones, lo que puede reducir las actualizaciones y las consultas.

Puede incrustar datos con una relación 1:1 dentro de un solo documento. Dicho esto, los datos con una relación muchos:1 en la que aparecen "muchos" objetos con sus documentos principales también pueden ser buenos candidatos.

Almacenar este tipo de datos en el mismo documento parece una elección prudente. Sin embargo, la incrustación proporciona un mejor rendimiento para las operaciones de lectura con este tipo de localidad de datos.

Los modelos de datos integrados también pueden ayudar a los desarrolladores a actualizar los datos asociados en una sola operación de escritura. Esto funciona porque las escrituras de un solo documento son transaccionales.

Debería considerar el uso de referencias para los siguientes escenarios:

  • Cuando actualiza un segmento de documento y se vuelve más largo, mientras que el resto del documento es estático.
  • Cuando se accede a un documento pero contiene datos que rara vez se utilizan. La incrustación solo aumentaría los requisitos en memoria, por lo que la referenciación tiene más sentido.
  • Cuando el tamaño del documento supera el límite de documentos de 16 MB de MongoDB. Esto puede suceder cuando se modelan muchas:1 relaciones (por ejemplo, empleados:departamento ).

Examinar perfiles y patrones de consulta

Para la mayoría de los desarrolladores, el primer paso para optimizar el rendimiento es comprender los patrones de consulta reales y esperados. Una vez que conozca los patrones de consulta de su aplicación lo suficientemente bien, puede crear su modelo de datos y elegir los índices apropiados.

Los desarrolladores de MongoDB tienen acceso a varias herramientas poderosas que les permiten mejorar el rendimiento. Pero eso no significa que se puedan ignorar los perfiles y patrones de consulta.

Por ejemplo, una manera fácil de aumentar el rendimiento es analizar sus patrones de consulta y comprender dónde puede incrustar datos. Otras formas de reforzar el rendimiento de MongoDB después de identificar sus principales patrones de consulta incluyen:

  • Asegurándose de tener índices en cualquier campo que consulte.
  • Almacenar los resultados de subconsultas frecuentes sobre documentos para reducir la carga de lectura.
  • Eche un vistazo a sus registros para ver las consultas lentas y luego verifique sus índices.

Revisar la indexación y el modelado de datos

Al crear su modelo de datos, decidirá cómo modelar las relaciones entre los datos. Elegir cuándo incrustar un documento en lugar de crear una referencia en documentos separados en diferentes colecciones, por ejemplo, es un ejemplo de consideración específica de la aplicación.

Una gran ventaja de los documentos JSON es que permiten a los desarrolladores modelar datos en función de los requisitos de la aplicación. Los subdocumentos anidados y las matrices lo ayudan a modelar relaciones complejas entre datos al aprovechar documentos de texto simples.

También puede usar MongoDB para modelar lo siguiente:

  • Datos geoespaciales
  • Estructuras tabulares, planas y columnares.
  • Pares clave-valor simples
  • Datos de series de tiempo
  • Bordes y nodos de estructuras de datos de gráficos conectados y similares

Supervisar fragmentación y replicación

La replicación puede ser fundamental para mejorar el rendimiento, ya que aumenta la disponibilidad de los datos a través del escalado horizontal. La replicación puede conducir a un mejor rendimiento y más seguridad a través de la redundancia.

La supervisión del rendimiento puede ser una molestia que requiere recursos y tiempo adicionales para garantizar un funcionamiento sin problemas. Puede aprovechar las herramientas de monitoreo de rendimiento disponibles en el mercado que se adaptan a sus necesidades específicas.

Por ejemplo, Kinsta APM puede obtener información con marca de tiempo sobre las consultas de la base de datos MySQL de su sitio de WordPress, los procesos de PHP, las llamadas HTTP externas y mucho más. También puede usar esta herramienta gratuita para depurar:

  • Largas llamadas a la API
  • Solicitudes de URL externas largas
  • Consultas de bases de datos lentas, por nombrar algunas.

En MongoDB, la replicación se puede lograr a través de conjuntos de réplicas que permiten a los desarrolladores copiar datos de un nodo principal o servidor a través de múltiples secundarios. Esto permite que su replicación ejecute algunas consultas en los secundarios en lugar del principal, lo que evita la contención y conduce a un mejor equilibrio de carga.

Los clústeres fragmentados en MongoDB son otra forma de mejorar potencialmente el rendimiento. De forma similar a la replicación, la fragmentación se puede utilizar para distribuir grandes conjuntos de datos en varios servidores.

Al aprovechar una clave de fragmento, los desarrolladores pueden copiar fragmentos o fragmentos de datos en varios servidores. Estos servidores pueden trabajar juntos para usar todos los datos.

Sharding tiene una buena cantidad de ventajas, incluida la escala horizontal para escrituras/lecturas, mayor disponibilidad y mayor capacidad de almacenamiento.

Determinar el uso de la memoria

MongoDB funciona mejor cuando el conjunto de trabajo de una aplicación (es decir, datos e índices a los que se accede con frecuencia) cabe en la memoria sin problemas. Mientras que otros factores son fundamentales para el rendimiento, el tamaño de la RAM es el más importante para el tamaño de la instancia.

Cuando el conjunto de trabajo de una aplicación cabe en la RAM, la actividad de lectura del disco debe ser baja. Pero si su conjunto de trabajo excede la memoria RAM del servidor de la instancia o el tamaño, la actividad de lectura comenzará a dispararse.

Si ve que esto sucede, es posible que pueda resolver el problema moviéndose a una instancia más grande que tenga más memoria.

Coloque campos de valores múltiples al final

Si está indexando un par de campos y uno de los campos que desea consultar utiliza uno de esos operadores de "valores múltiples", debe colocarlos al final del índice. Debe ordenar el índice de modo que los campos consultados para valores exactos aparezcan primero y los operadores de "valores múltiples" aparezcan en último lugar en el índice.

Una excepción a esto sería ordenar contra los campos. Colóquelos entre los campos "multivalor" y exacto para reducir la cantidad de clasificación en memoria necesaria.

Resumen

Para MongoDB, la velocidad es el nombre del juego. Para devolver consultas rápidamente, MongoDB aprovecha los operadores para ejecutar tareas matemáticas o lógicas. En pocas palabras, comprender los operadores de MongoDB es la clave para dominar MongoDB.

Este artículo destacó algunos de los operadores clave de MongoDB que puede usar en sus datos, como operadores de comparación, operadores lógicos, metaoperadores y operadores de proyección, por nombrar algunos. También lo ayuda a comprender cómo puede usar los operadores de MongoDB y las mejores prácticas que le permitirán aprovecharlos al máximo.

Entre todos los operadores, ¿cuál(es) usa con más frecuencia y por qué? Comparta en los comentarios a continuación: ¡nos encantaría escuchar sus pensamientos!