9 tipos de operadores Mongodb que você precisa conhecer
Publicados: 2022-09-09Em qualquer negócio, os dados são seu maior ativo. Ao analisar dados, você pode tomar decisões sobre tendências de clientes e previsão de comportamento. Isso aumenta a lucratividade do negócio e a tomada de decisão eficaz.
Sem software de banco de dados, uma tarefa simples como encontrar a média de todos os valores em um sistema cheio de registros seria tediosa. Felizmente, os bancos de dados tornaram a análise de dados mais fácil e rápida com funções e operadores.
Este artigo lançará alguma luz sobre os operadores usados no software de banco de dados MongoDB.
O que são operadores MongoDB?
MongoDB é um software de banco de dados NoSQL que gerencia informações orientadas a documentos.
Um dos principais recursos do MongoDB é sua velocidade. Para retornar consultas mais rapidamente, o MongoDB pode usar operadores para executar funções específicas.
Os operadores são símbolos especiais que ajudam os compiladores a realizar tarefas matemáticas ou lógicas. O MongoDB oferece vários tipos de operadores para interagir com o banco de dados.
Tipos de Operador MongoDB
Existem nove tipos de operadores, cada um nomeado para sua função. Por exemplo, os operadores lógicos usam operações lógicas. Para executá-los, você precisa usar uma palavra-chave específica e seguir a sintaxe. No entanto, eles são bastante fáceis de seguir!
Ao final do artigo, você poderá aprender o básico de cada operador e suas funções.
Operadores lógicos
Os operadores lógicos são frequentemente usados para filtrar dados com base nas condições fornecidas. Eles também permitem a avaliação de muitas condições, que discutiremos com mais detalhes.
Abaixo estão alguns operadores lógicos que você pode usar:
$ e
Uma condição “e” executa uma operação lógica “e” em uma matriz de duas ou mais expressões. Seleciona os documentos onde todas as condições das expressões são satisfeitas.
Esta é a sintaxe padrão para a expressão $and :
{ $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } Por exemplo, se quisermos selecionar documentos onde o preço é $ 10 e a quantidade é menor que 15, podemos inserir a seguinte consulta: db.inventory.find( { $and: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )$ ou
Uma condição “ou” executa uma operação lógica “ou” em uma matriz de duas ou mais expressões. Seleciona os documentos onde pelo menos uma das expressões é verdadeira.
Esta é a sintaxe padrão para a expressão $or :
{ $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }.Por exemplo, se quisermos selecionar documentos cujo preço seja $ 10 ou a quantidade seja menor que 15, podemos inserir a seguinte consulta:
db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )Não precisamos limitar a expressão a dois critérios — podemos adicionar mais. Por exemplo, a consulta abaixo seleciona os documentos em que o preço é igual a US$ 10, a quantidade é inferior a 15 ou a etiqueta está fixa:
db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 }, { tag: stationary }] } ) Ao executar essas cláusulas, o MongoDB executa uma varredura de coleção ou uma varredura de índice. Se todos os índices suportarem as cláusulas, o MongoDB usará índices para verificar uma expressão $or . Caso contrário, ele usa uma verificação de coleção.
Mas se você quiser testar os critérios no mesmo campo, talvez queira usar o operador $in vez do operador $or . Por exemplo, se você quiser uma coleção de documentos em que a quantidade seja 10 ou 20, talvez seja necessário executar a consulta $in abaixo:
db.inventory.find ( { quantity: { $in: [20, 50] } } ) Abordaremos mais sobre o operador $in mais tarde.
$nor
Este operador executa uma operação lógica “nor” em um array usando uma ou mais expressões. Em seguida, ele seleciona os documentos que falham nas expressões de consulta. Em termos mais simples, faz o oposto da condição $or .
Esta é a sintaxe geral:
{ $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }Vamos considerar a seguinte consulta:
db.inventory.find( { $nor: [ { price: 3.99 }, { sale: true } ] } )Esta consulta seleciona os documentos que contêm:
- um valor de campo de preço diferente de $ 3,99 e um valor de venda diferente de verdadeiro; ou
- um valor de campo de preço não igual a $ 3,99 e um campo de venda vazio ou ausente; ou
- nenhum campo de preço e um campo de venda diferente de verdadeiro; ou
- nem campo de preço nem campo de venda preenchido ou presente.
$não
Este operador executa uma operação lógica “não” em uma matriz para a expressão especificada. Em seguida, ele seleciona os documentos que não correspondem às expressões de consulta. Isso inclui os documentos que não contêm o campo.
Esta é a sintaxe geral:
{ field: { $not: { <operator-expression> } } }Por exemplo, faça a seguinte consulta:
db.inventory.find( { price: { $not: { $lt: 3.99 } } } )Essa consulta selecionaria os documentos que contêm:
- um campo de preço cujo valor é maior ou igual a $ 3,99; e
- um campo de preço não está preenchido ou não existe.
Operadores de comparação
Os operadores de comparação podem ser usados para comparar valores em um ou mais documentos.
Abaixo está um código de amostra de uma coleção de inventário simples para uma loja 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 exemplo ao detalhar cada operador de comparação a seguir.
Igual a ($eq)
Este operador corresponde a valores que são iguais ao valor fornecido:
{ <field>: { $eq: <value> } }Por exemplo, se quisermos recuperar um documento específico da coleção de inventário com o valor exato da quantidade “20”, inseriremos o seguinte comando:
db.inventory.find( { qty: { $eq: 20 } } )A consulta retornaria o seguinte:
{ _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }Maior que ($gt)
Este operador corresponde se os valores forem maiores que o valor fornecido:
{ field: { $gt: value } }Neste exemplo, recuperamos os documentos onde a quantidade é maior que 15:
db.inventory.find({"qty": { $gt: 15}})A consulta retornaria o seguinte:
{ _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 corresponde se os valores forem menores que o valor fornecido:
{ field: { $lt: value } }Vamos encontrar os documentos com uma quantidade inferior a 25:
db.inventory.find({"qty": { $lt: 25}})A consulta retornaria o seguinte:
{ _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" ] }Maior ou igual a ($gte)
Este operador corresponde quando os valores são maiores ou iguais ao valor fornecido:
{ field: { $gte: value } }Neste exemplo, recuperamos os documentos onde a quantidade é maior ou igual a 25:
db.inventory.find({"qty": { $gte: 25}})Essa consulta retornaria o seguinte:
{ _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 ou igual a ($lte)
Este operador corresponde apenas se os valores forem menores ou iguais ao valor fornecido:
{ field: { $lte: value } }Vamos encontrar os documentos com uma quantidade menor ou igual a 25.
db.inventory.find({"qty": { $lte: 25}})Podemos esperar que essa consulta retorne o seguinte:
{ _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" ] }Em ($ em)
Este operador retorna os documentos que correspondem aos valores especificados:
{ field: { $in: [<value1>, <value2>, ... <valueN> ] } }O valor de um campo é igual a qualquer valor na matriz especificada. Para recuperar os documentos com valores “30” e “15” na coleção de inventário, por exemplo, você faria assim:
db.collection.find({ "qty": { $in: [30, 15]}})A saída seria:
{ _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" ] } Não em ($nin)
Este operador retorna os documentos que não correspondem aos valores fornecidos. Aqui está a sintaxe básica do operador $nin :
{ field: { $nin: [ <value1>, <value2> ... <valueN> ] $nin seleciona os documentos onde:
- o valor do campo não está na matriz especificada; ou
- o campo não existe.
Se o campo contiver matrizes, ele selecionará matrizes onde nenhum elemento especificado na seção de valor estiver presente. Por exemplo, queremos selecionar os documentos em que a quantidade não é igual a 20 ou 15.
Além disso, também corresponde a documentos que não possuem um campo de quantidade:
db.collection.find({ "qty": { $nin: [ 20, 15 ]}}, {_id: 0})A saída seria:
{ _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" ] }Diferente ($ne)
O operador $ne retorna os documentos onde o valor especificado não é igual:
{ $ne: value } }Por exemplo, digamos que queremos selecionar todos os documentos em que a quantidade não seja igual a 20:
db.inventory.find( { qty: { $ne: 20 } } )A saída seria:
{ _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" ] }A partir da saída acima, podemos ver que a consulta selecionará documentos que não possuem um campo de quantidade.
Operadores de elemento
Os operadores de consulta de elemento podem identificar documentos usando os campos do documento. Os operadores de elemento consistem em $exist e $type .
$existe
Este operador corresponde a documentos que possuem um campo especificado. Este operador tem um valor booleano que pode ser true ou false .
Se especificado como true , corresponde aos documentos que contêm esse campo, incluindo documentos em que o valor do campo é nulo. Se <boolean> for false , a consulta retornará apenas os documentos que não contêm o campo.
Aqui está a sintaxe padrão:
{ field: { $exists: <boolean> } }Vamos dar um exemplo onde temos uma coleção de dados para um array chamado “bagofmarbles”, onde cada saco contém bolinhas de gude de cores diferentes:
{ 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 uma consulta que retorne apenas aqueles sacos onde existem bolinhas vermelhas. Isso significa que teríamos que inserir o valor booleano como true . Vamos dar uma olhada:
db.bagofmarbles.find( { red: { $exists: true } } ) Os resultados consistiriam naqueles documentos que contêm o campo “vermelho”, mesmo que o valor seja null . No entanto, não consistiria nos documentos onde o campo “vermelho” nem existia:
{ 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 }Se quisermos apenas aqueles sacos onde as bolinhas vermelhas nem existem como campo, podemos inserir a consulta abaixo:
db.bagofmarbles.find( { red: { $exists: false} }Os resultados seriam aqueles documentos que não contêm o campo “vermelho”:
{ green: 2, blue: 4 } { green: 2 } { blue: 6 }$tipo
Este operador corresponde aos documentos de acordo com o tipo de campo especificado. Isso é útil quando você tem dados altamente não estruturados ou quando os tipos de dados não são previsíveis. Esses tipos de campo são tipos BSON especificados e podem ser definidos pelo número do tipo ou alias.
Esta é a sintaxe geral para $type :
{ field: { $type: <BSON type> } }Digamos que temos um catálogo de endereços contendo os documentos abaixo:
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" ] } ] }Ao observar os documentos acima, o CEP possui diferentes tipos de dados. Isso inclui valores long, double, integer e string.
Se quisermos apenas os documentos que têm um tipo de dados especificado como o CEP — vamos usar string para esta instância — teríamos que inserir a seguinte consulta no compilador:
db.addressBook.find({ "zipCode": { $type: "string" } })Isso retornaria os seguintes documentos:
[ { "_id": 1, "address": "2100 Jupiter Spot", "zipCode": "9036325" }, { "_id": 5, "address": "1044 Venus Lane", "zipCode": [ "99883637232", "73488976234" ] } ] Além disso, há um tipo “number”, que inclui todos os valores long, integer ou double como um array contendo um elemento dos tipos especificados:
db.addressBook.find( { "zipCode" : { $type : "number" } } )Resultado:
[ { "_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) } ] Se os documentos tiverem um tipo de campo array, o operador $type retornará os documentos nos quais pelo menos um elemento do array corresponde ao tipo passado ao operador.
Operadores de matriz
O MongoDB também consiste em operadores de array, para consultar documentos contendo arrays.
Existem três operadores principais: $all , $elemMatch e $size . Discutiremos cada um em detalhes abaixo.
$todos
O operador $all escolhe os documentos nos quais o valor de um campo é um array contendo os elementos especificados:
{ : { $all: [ <value1> , <value2> ... ] } }Por exemplo, digamos que temos uma coleção de documentos para uma loja de roupas, com o seguinte em inventário.
{ _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" } ] } Gostaríamos de recuperar todos os documentos (neste caso, as roupas) do inventário que estão vinculados às tags “trendy” e “y2k”. A consulta abaixo usa o operador $all onde o valor do campo tags é um array cujos elementos incluem “y2k” e “trendy”:
db.inventory.find( { tags: { $all: [ "y2k", "trendy" ] } } )A consulta acima retorna o seguinte:
{ _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" } ] } No exemplo acima, também descobrimos que o operador $all simplesmente executa a mesma função que a operação $and .
Alternativamente, poderíamos usar a consulta abaixo, que daria uma saída semelhante à acima:
db.collection.find({ $and: [ { tags: "y2k" }, { tags: "trendy" } ] }) $elemMatch
O operador $elemMatch corresponde a documentos que contenham um campo de matriz com pelo menos um elemento que corresponda a todos os critérios de consulta especificados:
{ : { $elemMatch: { <query1>, <query2>, ... } } } Embora possamos usar operadores de comparação como $lte e $gte , se especificarmos apenas uma única condição de consulta dentro $elemMatch , e não estivermos usando os operadores $not ou $ne , a utilização de $elemMatch pode ser omitida, pois seria essencialmente executar a mesma função.
Há mais algumas coisas a serem lembradas ao usar este operador, principalmente:
- Você não pode especificar uma expressão
$whereem uma operação$elemMatch. - Você não pode especificar uma expressão de consulta
$textem uma operação$elemMatch.
Por exemplo, temos os seguintes documentos na coleção de resultados dos alunos:
{ _id: 1, results: [ 92, 89, 98 ] } { _id: 2, results: [ 85, 99, 99 ] }A consulta a seguir corresponde apenas aos documentos em que a matriz de resultados contém pelo menos um elemento maior ou igual a 90 e menor que 95:
db.studentresults.find( { results: { $elemMatch: { $gte: 90, $lt: 95 } } })Nossa consulta retorna o seguinte documento, pois o elemento 92 é maior ou igual a 90 e menor que 95:
{ "_id" : 1, "results" :[ 92, 89, 98 ] }$tamanho
O operador $size retorna os documentos em que o tamanho do array corresponde ao número de elementos especificados no argumento:
{ field: { $size: value } }Aqui está um exemplo:
db.collection.find( { field: { $size: 2 } }); Isso retornaria todos os documentos na coleção especificada onde o campo é uma matriz com 2 elementos: { field: [ orange, apple] } e { field: [ blue, red] } , mas não { field: blue} ou { field: [ raspberry, lemon, grapefruit ] } .
No entanto, embora possamos inserir o valor específico como tamanho, não podemos especificar intervalos de valores como tamanho.
Operadores geoespaciais
O MongoDB permite armazenar dados geoespaciais na forma de tipos GeoJSON. GeoJSON é um formato de padrão aberto baseado na notação de objeto JavaScript que pode representar recursos geográficos e dar suporte a atributos não espaciais. Existem dois tipos de operadores geoespaciais sobre os quais falaremos neste artigo: especificadores de geometria e seletores de consulta.
$geometria
Este operador menciona a geometria GeoJSON para uso com os seguintes operadores de consulta geoespacial: $geoIntersects , $geoWithin , $nearSphere e $near . $geometry aproveita o EPSG:4326 como o sistema de referência de coordenadas (CRS) padrão.
Para mencionar objetos GeoJSON com o CRS padrão, você pode aproveitar o seguinte snippet para $geometry :
$geometry: { type: "<GeoJSON object type>", coordinates: [ <coordinates> ] } Para mencionar um polígono GeoJSON de anel único com um MongoDB CRS personalizado, você pode usar o seguinte trecho (você só pode usar isso para $geoWithin e $geoIntersects ):
$geometry: { type: "Polygon", coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } }$polígono
O operador $polygon pode ser usado para especificar um polígono para uma consulta geoespacial $geoWithin em pares de coordenadas herdados. Essa consulta retornará pares que se enquadram nos limites do polígono. No entanto, $polygon não consultará nenhum objeto GeoJSON. Para definir um polígono, você precisa especificar uma matriz de pontos de coordenadas da seguinte forma:
{ : { $geoWithin: { $polygon: [ [ <x1> , <y1> ], [ <x2> , <y2> ], [ <x3> , <y3> ], ... ] } } }Aqui, o último ponto está implicitamente conectado ao primeiro. Você pode mencionar quantos pontos ou lados quiser.
Por exemplo, a consulta a seguir retornará todos os documentos que possuem coordenadas que existem dentro do polígono definido por [0,0], [1,5] e [3,3]:
db.places.find( { loc: { $geoWithin: { $polygon: [ [ 0 , 0 ], [ 1 , 5 ], [ 3 , 3 ] ] } } } )$geodentro
Este operador pode ser usado para escolher documentos com dados geoespaciais que estão completamente contidos em uma forma específica. A forma especificada pode ser um multipolígono GeoJSON, um polígono GeoJSON (com vários anéis ou anéis únicos) ou uma forma que pode ser definida por pares de coordenadas herdados.
O operador $geoWithin alavancará o operador $geometry para mencionar o objeto GeoJSON.
Para mencionar os multipolígonos ou polígonos GeoJSON por meio do Sistema de Referência de Coordenadas (CRS) padrão, você pode utilizar a sintaxe mencionada abaixo:
{ : { $geoWithin: { $geometry: { type: <"Polygon" or "MultiPolygon"> , coordinates: [ <coordinates> ] } } } } Para consultas $geoWithin que mencionam as geometrias GeoJSON com áreas maiores que um único hemisfério, o uso do CRS padrão levaria a consultas para as geometrias complementares.
Para mencionar um polígono GeoJSON de anel único com um MongoDB CRS personalizado, você pode aproveitar o protótipo mencionado abaixo na expressão $geometry :
{ : { $geoWithin: { $geometry: { type: "Polygon" , coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } } } } }O exemplo a seguir seleciona todos os dados loc que existem completamente dentro de um polígono GeoJSON, sendo a área do polígono menor que a área de um único hemisfério:
db.places.find( { loc: { $geoWithin: { $geometry: { type : "Polygon" , coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ] ] } } } } )$caixa
Você pode usar $box para especificar um retângulo para uma consulta geoespacial $geoWithin para fornecer documentos que estão dentro dos limites do retângulo, de acordo com seus dados de localização baseados em pontos. Ao usar $geoWithin com o $box , você obterá documentos com base nas coordenadas da consulta. Nesse cenário, $geoWithin não consultará nenhuma forma GeoJSON.
Para alavancar o operador $box , você precisa mencionar os cantos superior direito e inferior esquerdo do retângulo em um objeto de matriz:
{ <location field> : { $geoWithin: { $box: [ [ <bottom left coordinates> ], [ <upper right coordinates> ] ] } } }A consulta mencionada acima calculará a distância utilizando geometria planar (plana). A consulta a seguir retornará todos os documentos que estão dentro da caixa com pontos em: [0,0], [0,30], [30,0], [30,30]:
db.places.find ( { loc: { $geoWithin: { $box: [ [ 0,0 ], [ 30,30 ] ] } } } )$nearSphere
Você pode usar $nearSphere para mencionar um ponto para o qual uma consulta geoespacial retorna os documentos do mais próximo ao mais distante.
MongoDB usa geometria esférica para calcular as distâncias para $nearSphere . Ele precisará de um índice geoespacial da seguinte forma:
- Índice 2d para dados de localização descritos como pares de coordenadas herdados. Para alavancar um índice 2d em pontos GeoJSON, você precisa gerar o índice no campo de coordenadas do objeto GeoJSON.
- Índice 2dsphere para dados de localização descritos como pontos GeoJSON.
Para mencionar um ponto GeoJSON, você pode aproveitar a seguinte sintaxe:
{ $nearSphere: { $geometry: { type : "Point", coordinates : [ <longitude>, <latitude> ] }, $minDistance: <distance in meters>, $maxDistance: <distance in meters> } } Aqui, $minDistance e $maxDistance são opcionais. $minDistance pode limitar os resultados aos documentos que estão pelo menos na distância especificada do centro. Você pode usar $maxDistance para qualquer índice.
Agora, considere uma coleção de “lugares” que consiste em documentos com um campo de localização que possui um índice 2dsphere. O exemplo a seguir retornaria os pontos cuja localização é de pelo menos 2.000 metros e no máximo 6.000 metros do ponto escolhido, ordenados do mais próximo para o mais distante:
db.places.find( { location: { $nearSphere: { $geometry: { type : "Point", coordinates : [ -43.9532, 50.32 ] }, $minDistance: 2000, $maxDistance: 6000 } } } )$geoIntersects
O operador $geoIntersects permite selecionar documentos cujos dados geoespaciais cruzam com um objeto GeoJSON específico (ou seja, onde a convergência do objeto especificado e os dados não são vazios). Ele aproveita o operador $geometry para especificar o objeto GeoJSON.
Para mencionar multipolígonos ou polígonos GeoJSON por meio do sistema de referência de coordenadas (CRS) padrão, você pode usar a seguinte sintaxe:
{ <location field>: { $geoIntersects: { $geometry: { type: "<GeoJSON object type>" , coordinates: [ <coordinates> ] } } } } A instância a seguir usará $geoIntersects para selecionar todos os dados loc que cruzam com o polígono descrito pelo array de coordenadas:
db.places.find( { loc: { $geoIntersects: { $geometry: { type: "Polygon" , coordinates: [ [ [ 0, 0 ], [ 2, 6 ], [ 4, 1 ], [ 0, 0 ] ] ] } } } } )$centro
O operador $center menciona um círculo para uma consulta $geoWithin que retorna pares de coordenadas herdados que estão dentro dos limites do círculo.
$center não retorna objetos GeoJSON. Para aproveitar o operador $center , você precisa especificar uma matriz que contenha:
- O raio do círculo, medido nas unidades usadas pelo sistema de coordenadas.
- As coordenadas da grade do ponto central do círculo.
{ <location field> : { $geoWithin: { $center: [ [ <x> , <y> ] , <radius> ] } } }O exemplo mencionado abaixo retornará todos os documentos que possuem coordenadas que podem ser encontradas dentro do círculo centrado em [2,3] e com raio de 40:
db.places.find( { loc: { $geoWithin: { $center: [ [2, 3], 40 ] } } } )Operadores de projeção
Você pode usar operadores de projeção para mencionar os campos retornados por uma operação. Os operadores de projeção do MongoDB permitem que a função find() seja usada com argumentos de filtragem de dados. Isso ajuda os usuários a extrair apenas os campos de dados necessários de um documento. Assim, permite projetar dados transparentes e concisos sem afetar o desempenho geral do banco de dados.
$elemMatch (projeção)
O operador $elemMatch é responsável por limitar o conteúdo de um campo dos resultados da consulta para conter apenas o primeiro elemento correspondente à condição $elemMatch .
Aqui estão algumas coisas que você precisa ter em mente antes de usar $elemMatch :
- A partir do MongoDB 4.4, independentemente da ordem dos campos no documento, a projeção
$elemMatchde um campo existente retorna o campo após a inclusão de outros campos existentes. - Os operadores
$elemMatche$descrevem o primeiro elemento correspondente de uma matriz com base em uma condição especificada. O operador$projetaria o primeiro elemento de matriz correspondente de cada documento em uma coleção com base em alguma condição da instrução de consulta, enquanto o operador de projeção$elemMatchrecebe um argumento de condição explícito. Isso permite projetar com base em uma condição não presente na consulta ou se você precisar projetar com base em vários campos nos documentos incorporados da matriz.
Você também deve estar ciente das seguintes restrições antes de usar o operador $elemMatch em seus dados:
- Você não pode mencionar uma expressão de consulta
$textem um operador$elemMatch. - As operações
db.collection.find()em visualizações não suportam o operador de projeção$elemMatch.
O exemplo a seguir no operador de projeção $elemMatch pressupõe uma coleção de schools com os seguintes 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 }, ] } Nesse caso, a operação find() consulta todos os documentos em que o valor do campo CEP é 63110. A projeção $elemMatch retornaria apenas o primeiro elemento correspondente do array students onde o campo school tem um 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 } ] }$fatia (projeção)
O operador de projeção $slice pode ser usado para especificar o número de elementos em uma matriz para retornar no resultado da consulta:
db.collection.find( <query> , { <arrayField> : { $slice: <number> } } );Também pode ser expresso assim:
db.collection.find( <query> , { <arrayField> : { $slice: [ <number> , <number> ] } } );Para demonstrar o mesmo, você pode criar uma coleção de tweets de exemplo com os seguintes 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" } ] } ]) A operação a seguir usaria o operador de projeção $slice no array tweets para retornar o array com seus dois primeiros elementos. Se uma matriz contiver menos de dois elementos, todos os elementos da matriz serão retornados:
db.posts.find( {}, { comments: { $slice: 2 } } )Essa operação retornaria os seguintes 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" } ] }$ (projeção)
O operador posicional $ limita o conteúdo de uma matriz para retornar o primeiro elemento que corresponde à condição de consulta dessa matriz. Você pode usar $ no documento de projeção do método find() ou do método findOne() quando precisar apenas de um elemento de array específico nos documentos escolhidos.
É assim que a sintaxe do operador $ se parece:
db.collection.find( { <array>: <condition> ... }, { "<array>.$": 1 } ) db.collection.find( { <array.field>: <condition> ...}, { "<array>.$": 1 } ) Neste exemplo, a coleção de students consiste nos seguintes 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 ] } Na consulta a seguir, a projeção { "grades.$": 1 } retorna apenas o primeiro elemento maior ou igual a 89 para o campo grades :
db.students.find( { semester: 2, grades: { $gte: 89 } }, { "grades.$": 1 } )Esta operação retorna os seguintes documentos:
{"_id": 3, "grades": [95] }Operadores de avaliação
Você pode aproveitar os operadores de avaliação do MongoDB para avaliar a estrutura geral de dados ou o campo individual dentro de um documento.
Vejamos alguns operadores comuns de avaliação do MongoDB.
$mod
Você pode usar este operador para fazer a correspondência de documentos em que o valor de um campo especificado é igual ao restante após ser dividido por um valor especificado:
{ field: { $mod: [ divisor, remainder ] } }Digamos que você tenha uma tabela de carros pertencentes a diferentes marcas que você possui em seu showroom. A consulta a seguir forneceria todas as marcas de carros cujos números de ações estão em múltiplos de 250.
db.cars.find ( { qty: { $mod: [ 250,0 ] } } )$jsonSchema
O $jsonSchema permite que você corresponda aos documentos que correspondem ao esquema JSON especificado. A implementação do esquema JSON do MongoDB inclui a adição da palavra-chave bsonType , que permite usar todos os tipos BSON dentro do operador $jsonSchema .
bsonType pode aceitar os mesmos aliases de string que você usaria para o operador de type . Esta é a aparência da sintaxe de $jsonSchema :
{ $jsonSchema: <JSON Schema object> }Aqui, o objeto de esquema JSON é formatado com base no rascunho 4 do padrão de esquema JSON:
{ <keyword1>: <value1>, ... } Aqui está um exemplo para demonstrar como $jsonSchema funciona:
{ $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" } } } } } } Você também pode usar $jsonSchema em um validador de documento para impor o esquema especificado nas operações de atualização e inserção:
db.createCollection(<collection> , { validator: { $jsonSchema: <schema> } } ) db.runCommand( { collMod: <collection>, validator:{ $jsonSchema: <schema> } } ) Tenha em mente que há várias coisas não suportadas pelo operador $jsonSchema :
- O tipo inteiro. Você precisa aproveitar o tipo BSON long ou int com a palavra-chave bsonType.
- Palavras-chave desconhecidas.
- Vinculando propriedades e a hipermídia do esquema JSON, juntamente com o uso de referências JSON e ponteiros JSON.
$texto
O operador $text procuraria um texto dentro do conteúdo do campo especificado, indexado com um índice de texto:
{ $text: { $search: <string>, $language: <string>, $caseSensitive: <boolean>, $diacriticSensitive: <boolean> } }Nesse caso, o snippet de código a seguir filtrará a tabela para filtrar quaisquer carros que tenham o texto “Porsche” neles:
db.cars.find( { $text: { $search: "Porsche" } } )$regex
O operador $regex oferece recursos de expressão regular para padrões de correspondência de strings em consultas. O MongoDB aproveita expressões regulares compatíveis com Perl:
{<field> : /pattern/ <options>}O exemplo a seguir ajudaria a filtrar todos os carros que têm a string “$78900” presente neles:
db.cars.find( { price: { $regex: /$78900/ } } )$expr
O operador $expr permite que você aproveite as expressões de agregação na linguagem de consulta:
{ $expr: { <expression> } } Você também pode usar $expr para criar expressões de consulta que comparam campos do mesmo documento em um estágio $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
$wherequery operator to top-level documents. The$wherequery operator won't function in a nested document, like in a$elemMatchquery. - Generally, you should use
$whereonly 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$whereindependently 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> , ... ] } } O valor do campo deve ser uma instância BinData ou numérico para $bitsAllSet para corresponder ao documento atual.
No exemplo a seguir, estamos aproveitando uma coleção com os seguintes 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" }) A consulta mencionada abaixo usará o operador $bitsAllSet para testar se o campo a possui bits definidos na posição 1 e na posição 5, onde o bit menos significativo estaria na posição 0:
db.collection.find( { a: { $bitsAllSet: [ 1, 5 ] } }Essa consulta corresponderia aos seguintes documentos:
{ "_id" : 1, "a" : 54, "binaryValueofA" : "00110110" } { "_id" : 4, "a" : BinData(0,"Zg=="), "binaryValueofA" : "01100110" }$bitsAllClear
O operador $bitsAllClear corresponderá a documentos em que todas as posições de bits fornecidas pela consulta sejam claras ou 0 :
{ <field> : { $bitsAllClear: <numeric bitmask> } } { <field> : { $bitsAllClear: < BinData bitmask> } } { <field> : { $bitsAllClear: [ <position1> , <position2> , ... ] } } Usaremos o exemplo usado para $bitsAllSet aqui para demonstrar o uso de $bitsAllClear . A consulta a seguir usaria esse operador para verificar se o campo a tem os bits limpos nas posições 1 e 5:
db.collection.find( { a: { $bitsAllClear: [ 1, 5 ] } } )Essa consulta corresponderia aos seguintes documentos:
{ "_id" : 2, "a" : 20, "binaryValueofA" : "00010100" } { "_id" : 3, "a" : 20, "binaryValueofA" : "00010100" }Meta-operadores
Existem vários modificadores de consulta que permitem modificar o comportamento ou a saída de uma consulta no MongoDB. As interfaces de driver podem fornecer métodos de cursor que as envolvem para seu uso.
$ dica
O MongoDB preteriu o $hint desde a v3.2. Mas, esse operador ainda pode estar disponível para drivers MongoDB como Go, Java, Scala, Ruby, Swift, etc. Ele pode forçar o otimizador de consulta a alavancar um índice específico para atender a consulta, que pode ser mencionado por documento ou por nome do índice.
Você também pode usar o operador $hint para testar estratégias de indexação e desempenho de consulta. Por exemplo, faça a seguinte operação:
db.users.find().hint( { age: 1 } ) Essa operação retornaria todos os documentos da coleção chamados users , aproveitando o índice no campo age .
Você também pode mencionar uma dica usando um dos seguintes formulários:
db.users.find()._addSpecial( "$hint", { age : 1 } ) db.users.find( { $query: {}, $hint: { age : 1 } } ) Se existir um filtro de índice para a forma de consulta, o MongoDB simplesmente ignorará o $hint .
$comentário
O operador $comment permite anexar um comentário a uma consulta em qualquer contexto em que $query possa aparecer. Como os comentários se propagam para o log do perfil, adicionar um comentário pode facilitar a interpretação e o rastreamento do seu perfil.
Você pode aproveitar o $comment de três maneiras:
db.collection.find( { <query> } )._addSpecial( "$comment", <comment> ) db.collection.find( { <query> } ).comment( <comment> ) db.collection.find( { $query: { <query> }, $comment: <comment> } ) Se você deseja anexar comentários a expressões de consulta em outros contextos, como com db.collection.update() , aproveite o operador de consulta $comment em vez do metaoperador.
$max
Você pode mencionar um valor $max para especificar o limite superior exclusivo para um índice específico para restringir os resultados de find() . Este operador especificará o limite superior para todas as chaves de uma ordem específica no índice.
Mongosh fornece o seguinte método de wrapper max() :
db.collection.find( { <query> } ).max( { field1: <max value> , ... fieldN: <max valueN> } ) Você também pode mencionar $max com as duas formas a seguir:
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 exemplo, se você quiser especificar o limite superior exclusivo, lembre-se das seguintes operações em uma coleção chamada coleção que contém um índice { age: 1 } :
db.collection.find( { <query> } ).max( { age: 100 } ).hint( { age: 1 } ) Essa operação limitará a consulta aos documentos em que a idade do campo for menor que 100 e forçará um plano de consulta que verificará o índice { age: 1 } de minKey para 100.
$explicar
Este operador fornecerá informações sobre o plano de consulta. Ele retorna um documento que descreve os índices e processos usados para retornar a consulta. Isso pode ser útil ao tentar otimizar uma consulta.
Você pode mencionar o operador $explain em uma das seguintes formas:
db.collection.find()._addSpecial( "$explain", 1 ) db.collection.find( { $query: {}, $explain: 1 } )Práticas recomendadas para operadores do MongoDB
Nesta seção, veremos algumas das melhores práticas ao usar esses operadores do MongoDB.
Incorporação e referência
A incorporação é uma extensão natural da modelagem de dados. Ele permite evitar junções de aplicativos, o que pode reduzir atualizações e consultas.
Você pode incorporar dados com uma relação 1:1 em um único documento. Dito isso, dados com um relacionamento muitos:1 em que “muitos” objetos aparecem com seus documentos pai também podem ser bons candidatos.
Armazenar esses tipos de dados no mesmo documento parece uma escolha prudente. No entanto, a incorporação oferece melhor desempenho para operações de leitura com esse tipo de localidade de dados.
Os modelos de dados incorporados também podem ajudar os desenvolvedores a atualizar dados associados em uma única operação de gravação. Isso funciona porque as gravações de documento único são transacionais.
Você deve considerar o uso de referência para os seguintes cenários:
- Quando você atualiza um segmento de documento e ele continua ficando mais longo, enquanto o restante do documento é estático.
- Quando um documento é acessado, mas contém dados raramente usados. A incorporação só aumentaria os requisitos de memória, portanto, a referência faz mais sentido.
- Quando o tamanho do documento ultrapassa o limite de documentos de 16 MB do MongoDB. Isso pode acontecer ao modelar relacionamentos muitos:1 (por exemplo, funcionários:departamento ).
Examinar perfis e padrões de consulta
Para a maioria dos desenvolvedores, a primeira etapa para otimizar o desempenho é entender os padrões de consulta reais e esperados. Depois de conhecer bem os padrões de consulta do seu aplicativo, você pode criar seu modelo de dados e escolher os índices apropriados.
Os desenvolvedores do MongoDB têm acesso a várias ferramentas poderosas que permitem melhorar o desempenho. Mas isso não significa que perfis e padrões de consulta possam ser ignorados.
Por exemplo, uma maneira fácil de aumentar o desempenho é analisar seus padrões de consulta e entender onde você pode incorporar dados. Outras maneiras de aumentar o desempenho do MongoDB depois de identificar seus principais padrões de consulta incluem:
- Certificando-se de que você tem índices em todos os campos que você consulta.
- Armazenar os resultados de subconsultas frequentes em documentos para reduzir a carga de leitura.
- Dando uma olhada em seus logs para ver as consultas lentas e, em seguida, verificando seus índices.
Revisar Indexação e Modelagem de Dados
Ao fazer seu modelo de dados, você decidirá como modelar relacionamentos entre dados. Escolher quando incorporar um documento em vez de criar uma referência em documentos separados em coleções diferentes, por exemplo, é um exemplo de consideração específica do aplicativo.
Uma grande vantagem dos documentos JSON é que eles permitem que os desenvolvedores modelem dados com base nos requisitos do aplicativo. O aninhamento de subdocumentos e matrizes ajuda a modelar relacionamentos complexos entre dados, aproveitando documentos de texto simples.
Você também pode usar o MongoDB para modelar o seguinte:
- Dados geoespaciais
- Estruturas tabulares, planas e colunares
- Pares de valores-chave simples
- Dados de série temporal
- Bordas e nós de estruturas de dados de grafos conectados e similares
Monitorar Sharding e Replicação
A replicação pode ser fundamental para melhorar o desempenho, pois aumenta a disponibilidade de dados por meio do dimensionamento horizontal. A replicação pode levar a um melhor desempenho e mais segurança por meio da redundância.
O monitoramento de desempenho pode ser um aborrecimento, exigindo recursos e tempo adicionais para garantir o bom funcionamento. Você pode aproveitar as ferramentas de monitoramento de desempenho disponíveis no mercado que atendem às suas necessidades específicas.
Por exemplo, o Kinsta APM pode obter informações com carimbo de data/hora sobre as consultas ao banco de dados MySQL do seu site WordPress, processos PHP, chamadas HTTP externas e muito mais. Você também pode usar esta ferramenta gratuita para depurar:
- Chamadas de API longas
- Solicitações de URL externas longas
- Consultas de banco de dados lentas para citar alguns.
No MongoDB, a replicação pode ser obtida por meio de conjuntos de réplicas que permitem que os desenvolvedores copiem dados de um nó ou servidor primário em vários secundários. Isso permite que sua replicação execute algumas consultas em secundários em oposição ao primário, evitando contenção e levando a um melhor balanceamento de carga.
Clusters fragmentados no MongoDB são outra maneira de melhorar potencialmente o desempenho. Semelhante à replicação, a fragmentação pode ser usada para distribuir grandes conjuntos de dados em vários servidores.
Ao aproveitar uma chave de fragmentação, os desenvolvedores podem copiar fragmentos ou partes de dados em vários servidores. Esses servidores podem trabalhar juntos para usar todos os dados.
A fragmentação tem seu quinhão de vantagens, incluindo dimensionamento horizontal para gravações/leituras, maior disponibilidade e maior capacidade de armazenamento.
Determinar o uso da memória
O MongoDB funciona melhor quando o conjunto de trabalho de um aplicativo (ou seja, dados e índices acessados com frequência) cabe na memória sem problemas. Enquanto outros fatores são fundamentais para o desempenho, o tamanho da RAM é o mais importante para o dimensionamento da instância.
Quando o conjunto de trabalho de um aplicativo cabe na RAM, a atividade de leitura do disco precisa ser baixa. Mas se o seu conjunto de trabalho exceder a RAM do servidor de instância ou tamanho, a atividade de leitura começará a disparar.
Se você vir isso acontecendo, poderá resolver o problema movendo para uma instância maior que tenha mais memória.
Colocar campos de vários valores no final
Se você estiver indexando alguns campos e um dos campos que deseja consultar usa um desses operadores de “valores múltiplos”, você deve colocá-los no final do índice. Você precisa ordenar o índice para que os campos consultados para valores exatos venham primeiro e os operadores de “valores múltiplos” apareçam por último no índice.
Uma exceção a isso seria a classificação em relação aos campos. Coloque-os entre os campos “multi-value” e exatos para reduzir a quantidade de classificação na memória necessária.
Resumo
Para o MongoDB, velocidade é o nome do jogo. Para retornar consultas rapidamente, o MongoDB aproveita os operadores para executar tarefas matemáticas ou lógicas. Simplificando, entender os operadores do MongoDB é a chave para dominar o MongoDB.
Este artigo destacou alguns dos principais operadores do MongoDB que você pode usar em seus dados, como operadores de comparação, operadores lógicos, operadores meta e operadores de projeção, para citar alguns. Também ajuda a entender como você pode usar os operadores do MongoDB e as práticas recomendadas que permitirão que você tire o melhor proveito deles.
Entre todos os operadores, qual(is) você usa com mais frequência e por quê? Compartilhe nos comentários abaixo - adoraríamos ouvir seus pensamentos!