Conceitos de MongoDB e NoSQL

Conceitos de MongoDB e NoSQL

Olá leitor, hoje você vai aprender os principais conceitos relacionados ao banco de dados MongoDB, e também ao NoSQL 😉

Por acaso você já ouviu falar dele? Tem mais ou menos uma ideia de como ele funciona? E o termo NoSQL, já ouviu falar?

Ainda não? Então fica tranquilo que nesta lição eu vou te ensinar tudo o que você precisa saber antes de integrar seus projetos com o MongoDB 🥰

Mas antes, o ideal é que você aprende sobre NoSQL antes de mergulharmos de cabeça no banco do Mongo, sendo assim...

O que é NoSQL?

O termo NoSQL (não SQL, Não somente SQL) é um termo genérico que indica um banco de dados não relacional. 

Ele nada mais é do que método que promove soluções de armazenamento de arquivos e dados de forma não relacional.

Esses bancos de dados (NoSQL), são focados em documentos (documents), que são um aglomerado de arquivos JSON (seguindo uma estrutura de chave e valor) salvos dentro da estrutura do SGBD.

O que faz com que haja uma enorme diferença entre um banco de dados relacional, em que temos colunas e linhas agrupadas de maneira organizada, onde precisamos fazer o uso da linguagem SQL para manipular tais dados (como se fossem uma coluna de excel).

A principal ideia das bases de dados não relacionais, é que você não precise criar consultas utilizando a linguagem SQL, mas sim, que você trabalhe por meio de métodos de classes, que são capazes de realizar inserção, seleção, atualização e remoção desses dados (documents).

E não, NoSQL não faz a utilização uma estrutura SQL por trás dos panos, visto que ele é um banco de dados não relacional, e como dito anteriormente, ele trabalha exclusivamente com arquivos JSON.

Isso significa que em vez de organizar os dados em tabelas com linhas e colunas, como ocorre nos bancos de dados relacionais (SQL).

O NoSQL adota outros formatos, como documentos, grafos, chave-valor e colunas largas.

Cada um desses formatos, é otimizado para casos de uso específicos, oferecendo maior flexibilidade, escalabilidade e desempenho em comparação com os bancos de dados tradicionais, especialmente quando se lida com grandes volumes de dados não estruturados.

Mas calma aí ✋

🛑 Ao contrário do que você possa estar pensando (tipo de coisa que já foi muito difundida por aí), um banco de dados não relacional (NoSQL) não foi feito para substituir os bancos de dados relacionais (SQL) 🛑

Visto que a utilização desses bancos se torna muito comum em soluções específicas que atendem a determinados cenários. O que faz com que muitas aplicações façam o uso desses dois tipos de banco de dados em uma mesma aplicação.

Vejamos agora, uma comparação direta entre banco de dados NoSQL com banco de dados SQL 🙂

Quando usar NoSQL?

Usamos NoSQL, quando temos um grande volume de dados não estruturados ou quem sabe, semi-estruturados, como é o caso de dados que não se encaixam muito bem em uma estrutura rígida de tabelas (JSON, XML, Logs, Redes Sociais, etc).

Além disso, banco de dados NoSQL são otimizados para executar operações e consultas de forma rápida, especialmente em cenários de alta carga, como em aplicações de streaming em tempo real, ou funcionalidades presentes em redes sociais.

Pensa em NoSQL como um banco de dados que TAMBÉM foi feito para armazenar notificações de aplicativos, como aquelas cantadas, cupons de desconto, mensagens motivacionais (textos curtos para disparadas)... essas coisas.

Quando usar SQL?

No caso do SQL (bancos relacionais), esses tipos de bancos de dados, são melhores utilizados quando há uma estrutura bem definida de dados e o esquema de tabelas raramente muda.

Além disso, ele se faz ideal quando precisamos realizar consultas complexas (com JOINs, subconsultas, agregações) ou transações que envolvem várias tabelas, e que precisam de uma consistência forte (ACID).

Sendo assim, podemos definir que:

O que é o MongoDB?

Obviamente que o MongoDB é um banco de dados NoSQL, não é verdade? 😝

Apesar disso, vamos para uma explicação mais profissional....

O MongoDB é um banco de dados NoSQL orientado a documentos, e que foi projetado para armazenar grandes volumes de dados de maneira escalável e flexível. 

Ao contrário dos bancos de dados relacionais (MySQL, PostgreSQL, SQLite, MariaDB...) que armazenam informações em tabelas com linhas e colunas, o MongoDB armazena os dados em documentos JSON (ou BSON, que é uma versão binária do JSON), o que permite maior flexibilidade na estrutura dos dados.

Logo no início da vida do NodeJS, o MongoDB era a escolha ideal para "combar" com nossas aplicações. A grande maioria dos cursos e treinamentos voltados para NodeJS, sempre ensinam a utilizar o MongoDB como um banco de dados principal.

Só que com o passar do tempo, o mercado foi se dividindo, e hoje nós temos tanto aplicações feitas em NodeJS (que usam bancos relacionais), quanto outras que ainda continuam usando banco de dados não relacionais (e uma terceira via que usam ambas).

Apesar disso, o MongoDB ainda continua sendo a primeira escolha para aplicações feitas com NodeJS, mas cuidado, nem sempre é vantajoso utilizá-lo, portanto, use-o com cautela 🤓

Diferente do que vimos nos banco de dados relacionais (SQL) em lições passadas, quando se trata de NoSQL nós podemos fazer o uso de índices primários e secundários.

Um índice primário, nada mais é do que uma chave _id que é criada de forma automática sempre quando criamos um document.

Já um índice secundário, são criados manualmente para otimizar as consultas em outros campos que não sejam o campo _id.

Sobre esses índices, veremos o funcionamento deles com mais detalhes nos próximos 😉

De acordo com a própria documentação do MongoDB, ele é a escolha ideal para quem trabalha com:

Eu posso utilizar o MongoDB, e abandonar o uso de um banco de dados relacional?

Sim, você pode, mas faça isso desde que a sua aplicação seja pequena. Pois a medida em que ela vai crescendo e se tornando completa e complexa, o ideal é que voce considere fazer o uso de um banco de dado relacional para armazenar alguns dados que não fazem mais sentido estarem no MongoDB.

Dito isso, vamos aprender a instalar o MongoDB no Windows 😉

Instalando o MongoDB no Windows

O processo de instalação do MongoDB no windows é bem simples, basta seguir atentamente os passos abaixo.

Para instalar o MongoDB, você também vai precisar instalar o MongoDB Tools, que é uma ferramenta usada para importação e exportação de bancos de dados, e que vai nos ajudar bastante nesta jornada 😄

1° Passo) Na página de comunidade da ferramenta, dê um scroll para baixo, até localizar um formulário de opções para baixar a ferramenta:

Certifique-se de que a última versão está selecionada, a plataforma está marcada como Windows, e o pacote está como MSI. Após isso, clique no botão de [Download] para baixar a ferramenta.

O MongoDB tem ao todo 700MB de tamanho, e dependendo da sua conexão com a internet, esse processo pode ser demorado...

2° Passo) Após baixar o instalador, execute-o normalmente na sua máquina até aparecer a tela de boas vindas, quando isso acontecer, clique em [Next]:

3° Passo) Leia e aceite os termos de uso da ferramenta, e clique em [Next]:

4° Passo) Por padrão, recomendo que você faça uma instalação completa, portanto clique no botão [Complete]:

5° Passo) A próxima tela é referente a configuração do MongoDB, recomendo que você salve o caminho do Data Directory em um lugar seguro, pois iremos precisar dele mais tarde para adicioná-lo dentro das variáveis de ambiente do Windows (caso necessário).

Salvou o Data Directory? Então é só clicar em [Next] para seguir em frente 😉

Observação: o Data Directory está apontando para a pasta data, enquanto o caminho certo é a pasta bin, veremos como corrigir isso mais tarde.

6° Passo) Na tela seguinte, certifique-se de que a opção Mongo Compass está selecionada (iremos precisar dessa ferramenta também).

O Mongo Compass, atua como um gerenciador de banco de dados NoSQL, o que te ajuda a visualizar suas tabelas e interagir com elas.

Clique em [Next] para continuar.

7° Passo) Com tudo pronto para ser instalado, clique no botão [Install]:

Observação: este passo pode demorar alguns minutos.

8° Passo) Ao completar o processo de instalação, basta clicar em [Finish].

Após clicar em [finish], o Mongo Compass irá ser aberto logo em seguida, mas como não iremos configurá-lo agora, você pode fechar essa aplicação 😉

Com o MongoDB e o Mongo Compass instalados na sua máquina, só faltam mais dois personagem para que a nossa festa fique completa, o MongoDB Tools e o MongoDB Shell 🥳

Instalando o MongoDB Tools no Windows

O MongoDB Tools, ou como também é chamado de MongoDB Command Line Database Tools, é uma coleção de códigos utilitários que podem ser utilizados no seu terminal, e que possuem o objetivo de te axuliar com suas operações do MongoDB.

1° Passo) Na página de Downloads da ferramenta, certifique-se de que você está baixando a versão mais recente, e que a plataforma esteja setada para Windows.

Observação: certifique-se de que o pacote está na versão MSI, pois a ideia é que o pacote seja instalado no nosso sistema operacional.

Por fim, clique no botão [Download] para baixar a ferramenta.

2° Passo) Após o processo de download, abra o instalar normalmente, e na tela de boas vindas clique em [Next]:

3° Passo) Leia e aceite os termos de uso, e clique em [Next]:

4° Passo) Na tela seguinte, recomendo deixar as configurações da pasta de instalação no formato padrão (proposto pelo instalador) e clicar em [Next] para continuar:

5° Passo) Com tudo configurado, basta clicar no botão [Install] para instalar a ferramenta.

Observação: este procedimento pode levar alguns minutos.

6° Passo) Por fim, basta clicar em [Finish] para finalizar o instalador:

E pronto, o MongoDB Tools já está instalando (acabou de chegar na festa) 🥳

Instalando o MongoSH

Depois da versão 6.0.0 do MongoDB, o prompt de comando atrelado a ele (mongosh) deixou de ser incluído no processo de instalação, sendo assim, você também vai precisar instalar o MongoDB Shell.

Será por meio que conseguiremos acessar seu banco de dados via linha de comando, sendo assim, siga os passos abaixo 😉

1° Passo) Na página de Downloads, encontre a ferramenta MongoDB Shell, certifique-se de que a última versão está selecionada, a plataforma está setada como Windows, e a versão MSI esteja selecionada.

Em seguida, clique no botão [Download] para baixar a ferramenta:

2° Passo) Após o download, abra o instalador, e na tela de boas vindas, clique em [Next]:

3° Passo) Em seguida, recomendo você deixar a pasta de instalação de forma padrão, e clicar em [Next]:

A opção [Install just for you...] vai instalar o terminal só para você.

4° Passo) Com tudo configurado, basta clicar no botão [install] para instalar a ferramenta:

5° Passo) Por fim, clique em [Finish] para fechar o instalador.

Testando o MongoDB no Terminal

Com todas as 4 ferramentas instaladas na sua máquina local, chegou o momento de fazermos a validação final.

Para isso, com o seu terminal (Prompt de Comando) aberto em qualquer basta do seu computador, execute o comando abaixo:

mongosh

Se tudo ocorrer bem, uma mensagem de boas vindas com a versão do MongoDB irá aparecer no terminal:

Observação: para fechar o terminal, basta digitar o comando .exit e pressionar [ENTER].

Agora, caso apareça a seguinte mensagem: 'mongosh' não é reconhecido como um comando interno ou externo, um programa operável ou um arquivo em lotes.

Ou quem sabe: bash: mongosh: command not found.

Isso significa que o Windows não reconheceu o MongoDB Shell como um comando interno, sendo assim... precisamos adicioná-lo nas variáveis de ambiente do Windows!

Adicionando o MongoDB Shell nas variáveis de ambiente do Windows

Caso o comando mongosh não tenha sido reconhecido pelo seu sistema, fique tranquilo, pois irei te ensinar a como resolver isso agora 🤗

1° Passo) No menu inciar do Windows, mais especificamente na caixa de busca, digite: variáveis de ambiente.

Em seguida, clique no resultado [Editar as variáveis de ambiente do sistema] como consta na ilustração abaixo:

2° Passo) O Windows irá abrir uma caixa de opções, clique no botão [Variáveis de Ambiente]:

3° Passo) Um novo bloco irá se abrir, selecione a variável Path, e em seguida clique no botão [Editar]:

4° Passo) Na próxima tela, clique no botão [Novo], isso fará com que seja aberta caixa de edição na tabela esquerda.

Com a edição aberta para digitação, basta colar o caminho de instalação do MongoDB alí dentro.

Observação: lembra que eu pedi para você salvar o Data Directory em um lugar seguro? Então... agora é a hora de utilizá-lo, para isso, cole-o na tabela, e não se esqueça de modificar a pasta data para bin 😉

Observação: o caminho deve estar apontado para pasta bin, como consta no exemplo abaixo:

C:\Program Files\MongoDB\Server\8.0\bin

Além disso, recomendo adicionar mais duas variáveis ali dentro, uma relacionado ao MongoDB Shell, e outra relacionada ao MongoDB Tools:

C:\Users\William Lima\AppData\Local\Programs\mongosh\
C:\Program Files\MongoDB\Tools\100\bin

Lembrando que cada caminho deve estar separado em linhas diferentes da tabela, veja como ficou o resultado final:

Por fim, clique no botão [OK] para aplicar as configurações, e feche todas os blocos restantes clicando também em [OK].

5° Passo) Para testarmos se o que fizemos fez efeito, basta abrir um novo terminal (Prompt de Comando), e digitar o comando:

mongosh

Se tudo ocorrer bem, você vai se deparar com a seguinte mensagem no console:

Entendendo as principais entidades do MongoDB

Assim como acontece com os bancos de dados relacionais (SQL), os bancos não relacionais (NoSQL) também contam com suas próprias entidades e características específicas.

Englobando todos os outros conceitos que veremos a seguir, nós também temos o Database, que é representado por uma pasta de arquivos onde ficam armazenados as nossas collections e documents.

Para você que está acostumado com bancos relacionais, Database é equivalente a um banco de dados.

Dentro de um Database, nós temos as collections (que representariam as tabelas no SQL), e é dentro delas que iremos inserir nossos dados que ficarão armazenados.

Só que diferente dos bancos relacionais, em que os dados que ficam armazenados em nossas tabelas são chamados de DADOS, no MongoDB, esses dados possuem um outro nome, e são conhecidos como Documents.

Além disso, é importante ressaltar que nossas collections podem ser criadas livremente durante a lógica do nosso código, uma vez que elas não contam com colunas fixas.

O que atua de forma totalmente diferente das colunas do SQL, uma vez que aqui, isso passa a ser possível, e é tão fácil quanto adicionar uma chave em um objeto já existente no Javascript 🤓

No final das contas nós temos uma estrutura que pode ser representada da seguinte forma:

MongoDB e sua relação com os arquivos JSON (BSON)

Quando trabalhamos com MongoDB, os dados (documents) que são inseridos em nossas tabelas (collections), serão armazenados no formato BSON (ou Binary JSON) que representa uma variação do formato JSON.

Enquanto o JSON é um formato de texto leve e amplamente utilizado para transferir dados, o BSON oferece algumas vantagens em termos de desempenho. 

Esse novo formato, foi criado exclusivamente para ser utilizado em bancos de dados como o MongoDB, que lida com grandes volumes de documentos e, portanto, exige operações de leitura e escrita otimizadas.

Se você estivesse inserindo um documento em uma collection de usuários, o JSON poderia se parecer com isso:

{
  "_id": "650f0fa5ab12fd0012345678",
  "name": "João Silva",
  "age": 29,
  "email": "joao.silva@email.com",
  "createdAt": "2024-09-25T12:34:56Z",
  "isActive": true,
  "skills": ["JavaScript", "MongoDB", "Node.js"]
}

Já o MongoDB, pegaria esse formato, e o armazenaria em um formato binário (BSON), como é caso do exemplo:

\x16\x00\x00\x00                  // Document size
\x07_id\x00\x5c\xf1\xa5\xab\x12\xfd\x00\x12\x34\x56\x78 // ObjectId (binário)
\x02name\x00\x0a\x00\x00\x00João Silva\x00   // String (length + content)
\x10age\x00\x1d\x00\x00\x00                   // Integer (29)
\x02email\x00\x16\x00\x00\x00joao.silva@email.com\x00 // String
\x09createdAt\x00\x40\x24\x4e\x12\x34\x56\x00\x00 // Date
\x08isActive\x00\x01                          // Boolean (true)
\x04skills\x00\x34\x00\x00\x00                 // Array
   \x020\x00\x0b\x00\x00\x00JavaScript\x00
   \x021\x00\x08\x00\x00\x00MongoDB\x00
   \x022\x00\x08\x00\x00\x00Node.js\x00
\x00                                          // End of document

Apesar da visualização ser um pouco mais técnica, o MongoDB lida com isso de maneira transparente e extremamente rápida.

Mas é claro que no momento em que formos executar um SELECT, INSERT, UPDATE ou DELETE, é obvio nós desenvolvedores trabalhamos com o formato JSON, mas por de baixo dos panos, tais dados estão sendo representados e salvos no formato BSON.

O formato BSON dá suporte aos seguintes tipos de dados:

Apesar disso, ao usar MongoDB, você geralmente não precisa se preocupar com o formato BSON diretamente, pois o banco de dados lida com a conversão automática de JSON para BSON na hora das operações.

Agora que você já tem uma ideia de como o MongoDB funcional de verdade, que tal aprendermos a criar um banco de dados (Database), uma tabela (collection) e inserir alguns dados nela (documents)?

Criando um Database, Collection e Document com o MongoDB

O processo de criação de um banco de dados (Database) usando o MongoDB, é bem simples.

Com o seu terminal (Prompt de Comando) aberto em qualquer pasta do seu computador, basta abrir o MongoDB Shell digitando o seguinte comando:

mongosh

Este comando abrirá o terminal do MongoDB para que possamos digitar nossos códigos (está fazendo o login no banco de dados):

Para mostrar os bancos de dados existentes, basta digitar o comando:

show dbs

Por padrão, o MongoDB cria 3 bancos de dados, o admin, config e o local.

Em seguida, para criar um banco de dados cujo nome será mongodb-nodejs, usamos o comando abaixo:

use mongodb-nodejs

Observação: diferente dos bancos relacionais, o mongodb só cria um banco de dados quando de fato ele possui dados. Em outras palavras... não existe essa de criar um banco de dados vazio 😆

Se você notar, o terminal do mongosh está usando o banco mondogdb-nodejs, ou seja, ele está selecionado, mas não criado:

Tanto é que se você sair do terminal, e mais tarde executar um show dbs, verá que o banco mongodb-nodejs ainda não existe na base de dados. Motivo? Já explicado na observação acima 😉

Portanto, de acordo com a observação que acabamos de ler acima, vamos precisar criar o banco de dados em conjunto com uma collection, e não se esquecendo de adicionar um dado (document) pra ela:

db.tabela.insertOne({nome: "Micilini Roll"})

db: diz ao MongoDB que estamos nos referindo a tabela que está em uso (mongodb-nodejs).

tabela: é o nome da collection que estamos criando.

insertOne: é uma função aceita pelo MongoDB que é utilizada para fazer um INSERT. No caso dela, podemos fazer um insert simples, bastando apenas informar os dados em formato JSON.

Se tudo ocorrer bem, você receberá a seguinte mensagem no console:

Além disso, se você executar o comando show dbs, verá que o banco de dados acaba de ser criado de forma definitiva:

No caso da inserção acima, observe que o MongoDB adicionou uma chave única (ObjectId) para o registro que inserimos.

Recuperando os dados inseridos no MongoDB

Para recuperar um determinado documento dentro de uma collection no MongoDB, primeiro certifique-se de que você está usando o banco de dados desejado:

use mongodb-nodejs

Em seguida, basta utilizar quaisquer um dos métodos abaixo para realizar sua busca 😉

Se você quer buscar todos os documentos na coleção tabela, use o método find():

db.tabela.find()

Se você quer que os documentos sejam formatados de forma mais legível (com indentação), use o método find() mais o método pretty():

db.tabela.find().pretty()

Para buscar o primeiro documento que corresponda a uma condição, por exemplo: nome sendo "Micilini Roll":, use o método findOne, e passe os dados em formato JSON dentro dele.

db.tabela.findOne({ nome: "Micilini Roll" })

Se você quer buscar todos os documentos que têm um determinado valor para um campo, por exemplo, todos que têm o nome "Micilini Roll":

db.tabela.find({ nome: "Micilini Roll" })

Se você quer buscar documentos com múltiplos critérios, como nome sendo "Micilini Roll" e outro campo, como categoria sendo "Comida", basta passar ambos dentro de find():

db.tabela.find({ nome: "Micilini Roll", categoria: "Comida" })

Se você quer usar operadores de comparação, como >=, <, etc., para buscar dados, você pode usar o seguinte exemplo abaixo:

db.tabela.find({ preco: { $gte: 10 } })

Se você quer buscar documentos com valores específicos dentro de um array de valores, basta usar o $in:

db.tabela.find({ nome: { $in: ["Micilini Roll", "Outro Produto"] } })

Se você quiser recuperar documentos ordenados pelo campo preco em ordem crescente, basta usar o sort():

db.tabela.find().sort({ preco: 1 })

Ou, para ordem decrescente, use o valor negativo:

db.tabela.find().sort({ preco: -1 })

Se você quiser retornar apenas certos campos dos documentos, como apenas o campo nome, você pode fazer isso com projeção, por exemplo:

db.tabela.find({}, { nome: 1, _id: 0 })

No exemplo acima, o campo _id será excluído, e apenas o campo nome será retornado.

Se você quiser limitar a quantidade de documentos retornados, pode usar o método limit():

db.tabela.find().limit(5)

Se você quiser buscar documentos e paginar os resultados (pulando, por exemplo, os primeiros 10 documentos):

db.tabela.find().skip(10).limit(5)

Se o seu _id for do tipo ObjectId, você precisará usar o construtor ObjectId para fazer a busca. Por exemplo, se o ID do documento for "64ecf7a2c527d7a5e40056a4", a consulta seria:

db.tabela.findOne({ _id: ObjectId("64ecf7a2c527d7a5e40056a4") })

Se você tiver um _id que não é do tipo ObjectId, como uma string personalizada, você pode buscá-lo diretamente sem o uso de ObjectId. Por exemplo, se o _id for uma string como "meuId123":

db.tabela.findOne({ _id: "meuId123" })

Se você quiser buscar documentos com uma lista de IDs, pode usar o operador $in:

db.tabela.find({ _id: { $in: [ObjectId("64ecf7a2c527d7a5e40056a4"), ObjectId("64ecf7a2c527d7a5e40056b5")] } })

Ou, se os IDs forem strings, faça dessa forma:

db.tabela.find({ _id: { $in: ["meuId123", "meuId456"] } })

Operadores com MongoDB

No tópico anterior, você aprendeu a utilizar o operador $gte para fazer um tipo de comparação maior ou igual (>=).

Agora veremos uma lista imensa de outros tipos de operadores que podemos usar no MongoDB 😉

$eq: Igual a (equal):

{ campo: { $eq: valor } }

$ne: Diferente de (not equal):

{ campo: { $ne: valor } }

$gt: Maior que (greater than):

$gte: Maior ou igual a (greater than or equal):

{ campo: { $gte: valor } }

$lt: Menor que (less than):

{ campo: { $lt: valor } }

$lte: Menor ou igual a (less than or equal):

{ campo: { $lte: valor } }

$in: Está em um array de valores (in):

{ campo: { $in: [valor1, valor2, ...] } }

$nin: Não está em um array de valores (not in):

{ campo: { $nin: [valor1, valor2, ...] } }

$and: Retorna documentos que atendem a todas as condições:

{ $and: [ { campo1: valor1 }, { campo2: valor2 } ] }

$or: Retorna documentos que atendem a qualquer uma das condições:

{ $or: [ { campo1: valor1 }, { campo2: valor2 } ] }

$not: Inverte a condição de uma consulta:

{ campo: { $not: condição } }

$nor: Retorna documentos que não atendem a nenhuma das condições:

{ $nor: [ { campo1: valor1 }, { campo2: valor2 } ] }

$exists: Verifica se um campo existe ou não:

{ campo: { $exists: true } }

$type: Verifica o tipo de dado do campo:

$type: Verifica o tipo de dado do campo.

$expr: Permite fazer consultas baseadas em expressões:

{ $expr: { $gt: [ "$campo1", "$campo2" ] } }

$mod: Realiza operações de módulo:

{ campo: { $mod: [divisor, resto] } }

$regex: Faz comparações utilizando expressões regulares (regex):

{ campo: { $regex: /padrão/, $options: 'i' } }

$all: Verifica se todos os elementos estão presentes no array:

{ campo: { $all: [ valor1, valor2 ] } }

$elemMatch: Verifica se ao menos um elemento do array atende às condições:

{ campo: { $elemMatch: { campoInterno: valor } } }

$size: Verifica o tamanho do array:

{ campo: { $size: tamanho } }

$slice: Retorna uma fatia (parte) de um array:

{ campo: { $slice: [start, limit] } }

$regex: Faz a correspondência de uma string com uma expressão regular:

{ campo: { $regex: /abc/, $options: "i" } }

$options: Define opções para a expressão regular, como a insensibilidade a maiúsculas e minúsculas (i), busca multilinha (m), etc.

$geoWithin: Seleciona documentos com base em uma área geográfica:

{ localizacao: { $geoWithin: { $centerSphere: [ [ long, lat ], raio ] } } }

$near: Seleciona documentos próximos de um ponto geográfico:

{ localizacao: { $near: { $geometry: { type: "Point", coordinates: [ long, lat ] }, $maxDistance: 1000 } } }

Para saber mais sobre os operadores, não deixe de consultar a documentação da ferramenta.

Atualizando dados no MongoDB

Para atualizar um determinado document de algum registro existente em uma collection, o processo é bem simples, basta seguir segue a sintaxe abaixo:

db.<collection>.updateOne(
  { filtro },
  { $set: { campoAtualizado: novoValor } }
)

Lembrando que você pode adicionar mais chaves em um determinado registro (sem problema algum), por exemplo:

db.<collection>.updateOne(
  { filtro },
  { $set: {
      campoAtualizado: novoValor,
      campoAtualizadoDois: segundoValor,
      ....
  }}
)

Com o seu terminal (Prompt de Comando) aberto, e com seu banco de dados selecionado, basta seguir os exemplos abaixo 😉

Suponha que você tenha documentos na coleção tabela, e quer atualizar um documento onde o campo name seja "João Silva", de modo a alterar a sua idade para 30:

db.tabela.updateOne(
  { name: "João Silva" },    // Filtro para localizar o documento
  { $set: { age: 30 } }      // Atualização: define a nova idade
)

Este comando vai encontrar o documento onde o campo name é "João Silva" e atualizar o campo age para 30.

Se você quiser atualizar vários documentos que atendam a um critério, você pode usar o método updateMany da seguinte forma:

db.tabela.updateMany(
  { isActive: false },        // Filtro para encontrar todos os inativos
  { $set: { isActive: true } } // Atualiza o campo `isActive` para true
)

Se você quer fazer um update e ao mesmo tempo obter o documento atualizado de volta, você pode usar o método findOneAndUpdate para isso, por exemplo:

db.tabela.findOneAndUpdate(
  { name: "João Silva" },     // Filtro para localizar o documento
  { $set: { age: 30 } },      // Atualização
  { returnDocument: "after" } // Retorna o documento atualizado
)

Se você conhece o valor do _id do documento, e deseja fazer um update por ele, basta inserir o ObjectId da seguinte forma:

db.tabela.updateOne(
  { _id: ObjectId("650f0fa5ab12fd0012345678") },
  { $set: { age: 31 } }
)

Além disso, nós temos alguns operadores úteis que podemos usar no update:

Vejamos um exemplo:

db.tabela.updateOne(
  { name: "João Silva" },
  { $inc: { age: 1 } }  // Incrementa a idade em 1 (do valor número atual que a idade já está armazenado)
)

O comando acima é tão facilitador, que é a mesma coisa que recuperarmos a idade daquele registro, somar mais 1,  e fazer um update. Com ele, podemos fazer isso usando apenas uma única linha 😍

Removendo dados no MongoDB

Para remover algum document de uma de nossas collections, podemos usar os métodos deleteOne (remove o primeiro documento que encontrar seguindo um padrão específico) ou deleteMany (remove diversos documentos que seguem o padrão informado).

Veremos o funcionamento de cada um deles abaixo 😉

Para remove o primeiro documento encontrado que tenha o campo name igual a "Micilini Roll", podemos usar o deleteOne:

db.tabela.deleteOne({ name: "Micilini Roll" })

Para remove todos os documentos que tenham name de "Micilini Roll", usamos o deleteMany:

db.tabela.deleteMany({ name: "Micilini Roll" })

Adicionando Autenticação no MongoDB

Até o momento, fizemos o uso do MongoDB por meio de uma conexão direta, não é verdade?

Mas quando trabalhamos com bancos de dados relacionais, costumamos fazer login primeiro, para só depois... começar a "brincar com o banco", certo?

Mas será que isso é possível de ser feito com o MongoDB?

E a resposta é SIM 🤩

Com o MongoDB, nós podemos criar um login e senha de acesso para adicionar mais segurança a nossa aplicação, e isso se dá por meio do suporte a autenticação da ferramenta.

A primeira coisa que você precisa fazer, é habilitar o suporte a autenticação dentro do arquivo mongod.cfg (versão windows) ou mongod.conf (versão linux).

Este arquivo geralmente está localizado em: C:\Program Files\MongoDB\Server\8.0\bin\

Quando achar este arquivo, abra ele com qualquer editor de códigos, e adicione a chave authorization: enabled da seguinte forma:

Observação: não se esqueça de descomentar o texto security como monstrado na ilustração acima, e salvar o arquivo.

Feito isso, não se esqueça de reiniciar o MongoDB (ou a sua máquina local) para que suas alterações surtam efeito.

Por fim, basta abrir o seu terminal (Prompt de Comando), digitar mongosh (para entrar no terminal do MongoDB), entrar na tabela de admin por meio do comando:

use admin

E em seguida, criar novas permissões de acesso a um dos seus bancos de dados:

db.createUser({
  user: "meuUsuario",
  pwd: "minhaSenha123",
  roles: [
    { role: "readWrite", db: "meuBanco" }  // Permissões de leitura e escrita para o banco 'meuBanco'
  ]
})

O campo roles define as permissões do usuário. Neste exemplo, ele tem permissão de leitura e escrita no banco de dados "meuBanco".

Além disso, conseguimos ajustar os papéis de acordo com as necessidades, por exemplo, usando o papel read apenas para leitura, ou dbAdmin para administração do banco de dados.

Por fim, quando a autenticação estiver habilitada, você pode se conectar ao banco de dados usando o login e senha que você criou da seguinte forma:

mongosh -u "meuUsuario" -p "minhaSenha123" --authenticationDatabase "admin"

Exibindo suas collections

Da mesma forma que usamos o comando show dbs para mostrar todos os bancos de dados existentes.

Nós podemos usar o comando abaixo:

show collections

De modo a mostrar uma lista de tabelas (collections) existentes em nosso banco de dados.

Lembrando que o comando acima, deve ser executado quando você já estiver dentro de um banco de dados no mongosh.

Removendo suas collections

Por vezes, nós iremos criar nossas collections com nomes errados, e com isso, vamos querer removê-las.

Para remover uma collection, basta estar logado no seu banco de dados com o mongosh, e chamar a função drop da seguinte forma:

db.<collection>.drop()

Não se esqueça de renomear o termo <collection> para o nome real da sua tabela.

Lembrando que todos os dados (documents) relacionados a sua collection serão excluídos, portanto, tenha cuidado.

Removendo suas databases

Para remover um banco de dados inteiro com o MongoDB, junto com collections e documents, você pode usar a função dropDatabase():

db.dropDatabase();

Lembrando que o comando acima deve ser executado quando você já estiver dentro de um banco de dados no mongosh. 

Existe uma forma de remover bancos de dados dentro de um loop no nosso terminal, o que vai remover todos aqueles bancos que não são necessários (temporários):

// Obtém a lista de nomes de banco de dados
const dbNames = db.adminCommand({ listDatabases: 1 }).databases;

dbNames.forEach(function(database) {
  const dbName = database.name;
  // Verifica se o banco de dados não é um dos sistemas
  if (['admin', 'config', 'local'].indexOf(dbName) < 0) {
    // Obtém o banco de dados e o exclui
    db.getSiblingDB(dbName).dropDatabase();
    print("Banco de dados " + dbName + " excluído.");
  }
});

Importando dados em nosso banco de dados

Supondo que você tenha um arquivo em JSON com o seguinte conteúdo:

  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e01" },
    "nome": "Laptop Dell XPS 13",
    "categoria": "Eletrônicos",
    "preco": 8500.00,
    "estoque": 25,
    "descricao": "Laptop compacto com tela de 13 polegadas, Intel Core i7 e 16GB de RAM."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e02" },
    "nome": "Smartphone Samsung Galaxy S23",
    "categoria": "Eletrônicos",
    "preco": 4200.00,
    "estoque": 50,
    "descricao": "Smartphone com tela AMOLED de 6.1 polegadas, 128GB de armazenamento e câmera tripla."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e03" },
    "nome": "Cafeteira Nespresso",
    "categoria": "Eletrodomésticos",
    "preco": 700.00,
    "estoque": 60,
    "descricao": "Cafeteira automática para cápsulas de café, com design compacto."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e04" },
    "nome": "Tênis Nike Air Max",
    "categoria": "Moda",
    "preco": 599.90,
    "estoque": 80,
    "descricao": "Tênis esportivo com amortecimento Air Max, ideal para corrida e caminhada."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e05" },
    "nome": "Cadeira Gamer Cougar Armor",
    "categoria": "Móveis",
    "preco": 1200.00,
    "estoque": 10,
    "descricao": "Cadeira ergonômica para gamers, com ajuste de altura e inclinação."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e06" },
    "nome": "Smart TV LG OLED 55",
    "categoria": "Eletrônicos",
    "preco": 5500.00,
    "estoque": 15,
    "descricao": "Smart TV OLED de 55 polegadas, resolução 4K e compatível com assistentes de voz."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e07" },
    "nome": "Fone de Ouvido Bluetooth JBL",
    "categoria": "Eletrônicos",
    "preco": 399.00,
    "estoque": 100,
    "descricao": "Fones de ouvido sem fio com até 30 horas de autonomia."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e08" },
    "nome": "Micro-ondas Electrolux 32L",
    "categoria": "Eletrodomésticos",
    "preco": 899.00,
    "estoque": 35,
    "descricao": "Micro-ondas de 32 litros com painel digital e várias funções pré-programadas."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e09" },
    "nome": "Relógio Apple Watch Series 7",
    "categoria": "Eletrônicos",
    "preco": 3500.00,
    "estoque": 20,
    "descricao": "Relógio inteligente com monitoramento de saúde, GPS e resistência à água."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e0a" },
    "nome": "Câmera Canon EOS M50",
    "categoria": "Eletrônicos",
    "preco": 4400.00,
    "estoque": 12,
    "descricao": "Câmera mirrorless compacta com sensor APS-C e gravação em 4K."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e0b" },
    "nome": "Mochila Para Notebook Lenovo",
    "categoria": "Acessórios",
    "preco": 199.90,
    "estoque": 70,
    "descricao": "Mochila leve e resistente, ideal para notebooks de até 15.6 polegadas."
  },
  {
    "_id": { "$oid": "64cfa8e2e2e2d72e4c1f1e0c" },
    "nome": "Mouse Gamer Razer DeathAdder",
    "categoria": "Acessórios",
    "preco": 350.00,
    "estoque": 45,
    "descricao": "Mouse gamer ergonômico com sensor óptico de alta precisão e iluminação RGB."
  }

E queira importar esses dados para o seu banco de dados, a primeira coisa que você deve se atentar, é se você realmente instalou o MongoDB Command Line Tools (e suas ferramentas estão nas variáveis de ambiente).

Observação: caso ainda não tenha feito, volte em tópicos anteriores para aprender a instalar essa ferramenta.

Com a ferramenta instalada, e considerando que o arquivo em JSON está salvo na sua área de trabalho com o nome de produtos.json.

A primeira coisa que você precisa fazer é abrir o seu terminal (Prompt de Comando) na mesma pasta onde se encontro o arquivo produtos.json.

Após isso, gostaria que você desse uma olhada no comando abaixo:

mongoimport <arquivo> -d <database> -c <collection>

O comando acima realiza uma importação dentro de uma de suas collections do banco de dados.

<arquivo>: é o nome do arquivo que você deseja importar.

<database>: é o nome do banco de dados onde acontecerá a importação.

<collection>: é o nome da collection (tabela) para onde esses dados irão.

No fim das contas, o meu comando ficou desse jeito:

mongoimport produtos.json -d mongodb-nodejs -c tabela

Supondo que você já tenha um banco de dados inteiro exportado (pelo comando mongoexport) e queira importar novamente, basta executar a sintaxe abaixo:

mongostore <directory>

<directory>: é o caminho da pasta onde se encontram todos os arquivos do MongoDB que foram exportados.

Exportando dados em nosso banco de dados

Outra ação bem comum envolve a exportação de dados no nosso banco, e isso pode ser feito pela seguinte sintaxe:

mongoexport -c <collection> -d <database> -o <output>

<database>: é o nome do banco de dados onde acontecerá a importação.

<collection>: é o nome da collection (tabela) para onde esses dados irão.

<output>: é o nome do arquivo junto com o caminho de onde ele será salvo.

No meu caso, como eu quero que o meu banco seja exportado dentro da minha área de trabalho, eu precisei usar o comando abaixo dentro do meu terminal (Prompt de Comando), que estava aberto no meu desktop (isso faz com que o arquivo de exportação vá para a área de trabalho):

mongoexport -c tabela -d mongodb-nodejs -o produtos.json

Apesar do comando acima exportar apenas uma collection, você pode usar o mongodump para exportar o seu banco de dados inteiro:

mongodump -d <database> -o <output>

No caso do <output> você deve informar o nome da pasta em que seu banco de dados será salvo:

mongodump -d mongodb-nodejs -o meuBanco

Verificando o Status do MongoDB

O comando mongostat é responsável por trazer informações em tempo real sobre o estado do servidor MongoDB, permitindo monitorar o desempenho e a atividade do banco de dados.

Ele fornece métricas como o número de operações por segundo, tempo de resposta, uso de memória, estatísticas de entrada e saída em disco, conexões ativas e muito mais.

Essa ferramenta é útil para administradores e desenvolvedores que desejam identificar gargalos de desempenho e garantir que o MongoDB esteja funcionando de maneira otimizada.  

Para usá-lo, basta executar o comando abaixo no seu terminal (Promt de Comando) em qualquer pasta do seu computador:

mongostat

Veja o resultado no console:

Observação: as estatísticas são atualizadas em tempo real, e você não precisa ficar fechando e abrindo o terminal toda hora 😁

Trabalhando com o MongoDB Compass

Anteriormente nesta lição, eu te expliquei uma das necessidades de instalarmos a ferramenta MongoDB Compass em conjunto com o MongoDB.

O Compass nada mais é do que uma ferramenta na qual podemos fazer operações de forma visual em nossos bancos de dados (CRUD) NoSQL, e isso incluí collections e documents.

Usamos esta ferramenta especificamente para visualizarmos os registros que estão sendo salvos em nosso banco de dados 🙂‍↕️

Como nós instalamos ela na versão do Windows, eu te peço para que você abra a ferramenta, para que possamos conectar ao nosso banco de dados:

Para criarmos uma nova conexão com o banco de dados, basta clicar no botão [+ Add new connection].

No campo URI, é o local onde colocamos a URL do nosso MongoDB, geralmente ela está em mongodb://localhost:27017/.

Já o campo Name é o nome da conexão que iremos salvar para identificarmos mais tarde. No seu caso, você pode colocar qualquer texto alí dentro.

O campo Color é referente a cor em que iremos visualizar o nosso banco de dados (pura estética).

Se você configurou um sistema de autenticação, basta inserir as informações de login e senha na aba [Advanced Connection Options].

Apenas com essas configurações, você já está apto para se comunicar com o seu banco de dados, sendo assim, clique no botão [Connect] para seguir a diante.

Se tudo ocorrer bem, no canto esquerdo da ferramenta, você vai ver um menu que contém uma lista de bancos de dados do MongoDB:

Basta que você selecione um banco, que automaticamente o Compass vai te mostrar uma lista de collections relacionadas a ele:

E ao clicarmos em uma das collections, teremos acesso a todos os documents lá existentes.

Se você notar, é possível criar/modificar/consultar/remover bancos de dados, collections e até mesmo documents, basta apenas que você interaja com a ferramenta de forma visual, que por sua vez, é beeeem intutitiva 😍

Conclusão

Nesta lição você "tomou um banho" de MongoDB 😋

Onde aprendeu mais sobre NoSQL, MongoDB e sas principais características relacionadas a ele.

Na próxima lição, veremos como integrar o MongoDB com nossas aplicações feitas com NodeJS, até lá 😌