MongoDB Descomplicado: O Guia Definitivo para Iniciantes em MongoDB
Published: 2023-07-12 16:25:37

# **MongoDB** Descomplicado: O Guia Definitivo para Iniciantes em **MongoDB**

O **MongoDB** é um dos bancos de dados NoSQL mais populares do mundo. Sua flexibilidade e escalabilidade o tornam uma escolha ideal para projetos de todos os tamanhos. 

Neste tutorial, iremos explorar os conceitos básicos do **MongoDB** e fornecer uma introdução abrangente para iniciantes, criando uma simples aplicação em Node.js.

## O que é o **MongoDB**

O **MongoDB** é um banco de dados orientado a documentos, o que significa que ele armazena dados em formato de documentos BSON (Binary JSON). Esses documentos são semelhantes a objetos JSON, tornando o **MongoDB** fácil de entender e usar.

## Vantagens do **MongoDB**

Existem muitas vantagens em se usar o **MongoDB** no desenvolvimento de APIs e aplicações:

**Flexibilidade do esquema:** O **MongoDB** é um banco de dados NoSQL orientado a documentos, o que significa que não requer um esquema rígido como nos bancos de dados relacionais. Isso permite que você armazene documentos com estruturas diferentes no mesmo banco de dados, facilitando a adaptação às necessidades em constante mudança do seu projeto.

**Escalabilidade horizontal:** O **MongoDB** foi projetado para ser altamente escalável. Ele permite a distribuição dos dados em vários servidores, possibilitando um aumento de desempenho à medida que a carga de trabalho aumenta. É possível adicionar mais servidores conforme necessário, tornando o **MongoDB** adequado para aplicações com grande volume de dados e tráfego intenso.

**Desempenho rápido:** O **MongoDB** possui um mecanismo de indexação eficiente e acesso direto aos dados, o que contribui para um desempenho rápido. Ele suporta consultas complexas e pode manipular grandes quantidades de dados de forma eficiente, garantindo uma resposta rápida às solicitações.

**Modelo de dados flexível:** O **MongoDB** permite que você armazene dados complexos e estruturas aninhadas de forma nativa. Isso facilita a representação e o acesso aos dados, especialmente em cenários onde a estrutura dos dados pode variar entre documentos.

**Comunidade e suporte ativos:** O **MongoDB** possui uma comunidade ativa de desenvolvedores e uma empresa por trás dele que oferece suporte e atualizações frequentes. Isso significa que você terá acesso a recursos, documentação e suporte técnico de qualidade para auxiliá-lo na construção e manutenção de seus projetos.

## Desvantagens de se usar o **MongoDB**

Como em toda tecnologia, existem pontos desfavoráveis no uso do **MongoDB**.

**Consumo de recursos:** O **MongoDB** pode consumir mais recursos do sistema em comparação com alguns bancos de dados relacionais. Isso ocorre devido ao seu modelo de armazenamento flexível e indexação intensiva, o que pode exigir mais memória e capacidade de processamento.

**Complexidade de consultas:** Embora o **MongoDB** seja poderoso em termos de consultas, às vezes pode ser mais complexo de usar do que bancos de dados relacionais tradicionais. Consultas complexas podem exigir um conhecimento mais aprofundado da sintaxe e recursos específicos do **MongoDB**.

**Ausência de transações ACID:** O **MongoDB** não suporta transações ACID (Atomicidade, Consistência, Isolamento, Durabilidade) em todas as operações. Isso pode ser um problema em cenários onde a integridade dos dados é fundamental e transações complexas são necessárias.

**Falta de aderência a um esquema fixo:** Embora a flexibilidade do esquema seja uma vantagem, também pode ser uma desvantagem em certos casos. Em projetos com requisitos estritamente definidos e relacionamentos complexos entre os dados, a falta de um esquema fixo pode dificultar a manutenção e a consistência dos dados.

**Curva de aprendizado:** Para desenvolvedores acostumados com bancos de dados relacionais, o **MongoDB** pode exigir uma curva de aprendizado inicial. É necessário compreender os conceitos específicos do **MongoDB** e suas melhores práticas para aproveitar ao máximo o seu potencial.

Você deve pesar as vantagens e desvantagens na utilização desse banco de dados NoSQL em seus projetos. 

## Como começar com o **MongoDB**

Para começar a usar o **MongoDB**, você precisa seguir algumas etapas simples:

### Passo 1: Instalação

Faça o download do **MongoDB** no site oficial e siga as instruções de instalação adequadas ao seu sistema operacional.

Se quiser, pode seguir este tutorial que ensina a instalar o **MongoDB** nos sistemas operacionais Windows, Linux e Mac:

[Como instalar o **MongoDB**: Guia Passo a Passo para Windows, Mac e Linux](https://medium.com/code-write/como-instalar-o-mongodb-guia-passo-a-passo-para-windows-mac-e-linux-3240171d8ead)

### Passo 2: Conectar ao **MongoDB**

Após a instalação, você precisa se conectar ao **MongoDB**. O **MongoDB** usa o conceito de banco de dados e coleções. O banco de dados é o recipiente principal que armazena suas coleções. 

Vamos usar o Windows como exemplo para nos conectarmos ao **MongoDB**.

- Abra o menu Iniciar e pesquise por "Variáveis de ambiente".
- Selecione a opção "Editar as variáveis de ambiente do sistema".
- Na janela "Propriedades do Sistema", clique no botão "Variáveis de Ambiente".
- Na seção "Variáveis do sistema", selecione a variável "Path" e clique em "Editar".
- Clique em "Novo" e adicione o caminho do diretório bin do **MongoDB**. O caminho padrão é "C:\Program Files\**MongoDB**\Server{versão}\bin". Encontrando o **MongoDB** em Program Files e acessando a pasta _bin_, basta copiar o endereço do Explorer.
- Clique em "OK" em todas as janelas para salvar as alterações.

Agora basta abrir o terminal do Windows (CMD ou Power Shell) e executar o comando :

```bash
mongod
```

O servidor será iniciado e estará pronto para aceitar conexões. 

Em seguida, abra uma nova janela do terminal do Windows e digite o comando abaixo para se conectar ao **MongoDB**:

```bash
mongo
``` 

Isso abrirá o shell do **MongoDB**, onde você pode executar comandos e consultas.

Agora você está conectado ao **MongoDB** local no Windows. Você pode criar bancos de dados, coleções, inserir dados e realizar várias operações usando comandos do **MongoDB**.

### Comandos básicos do **MongoDB**

Vamos criar um banco de dados para uma biblioteca, uma coleção para livros e uma coleção para membros.

#### Criação de um banco de dados:

O comando para se criar bancos de dados no **MongoDB** é _use nome_do_banco_de_dados_. Nosso banco de dados se chamará biblioteca. Então, o comando para a criação será:

```bash
use biblioteca
```

Ver todos os bancos de dados:
```bash
show databases
```
ou

```bash
show dbs
```

#### Criação de uma coleção:

Uma coleção seria o equivalente, em um banco de dados relacional, a uma tabela.

Ao usarmos _db_ antes da função, estamos criando uma coleção no banco de dados que foi definido no comando anterior, ou seja, no banco _biblioteca_.

```bash
db.createCollection("livros")
```

E agora vamos criar a coleção de usuários, que, como definimos anteriormente, se chamará _membros_:

```bash
db.createCollection("membros")
```

#### Inserir um documento:

Um documento do **MongoDB** seria o equivalente, em um banco de dados relacional, aos registros de uma tabela. O comando para inserção de um documento seria _insertOne_:

 ```bash
db.nome_da_colecao.insertOne({campo1: valor1, campo2: valor2, ...})
``` 

Para inserir os dados de um livro em um documento, nosso comando, além de usar o _db_, precisa declarar a qual a coleção o documento pertence. Então o comando se inicia com *db.nome_da_coleção*, e só depois o *insertOne* é acrescentado.

```bash
db.livros.insertOne({titulo: "Percy Jackson e o Ladrão de Raios", autor: "Rick Riordan", editora: "Pendragon", lancamento: new Date("2023-07-12")})
```

Vamos inserir mais um livro.

```bash
db.livros.insertOne({titulo: "Pega-pega com Folclóricos", autor: "Rod Zandonadi", editora: "Griots", lancamento: new Date("2022-08-12")})
```

#### Listar documentos no **MongoDB**:

Agora temos dois livros cadastrados em nosso banco de dados. Para listá-los, usamos o comando _find_.

```bash
db.livros.find()
```

#### Inserir mais de um documento no **MongoDB**:

Vamos, agora, criar alguns usuários, os membros da nossa biblioteca. Porém, para não precisarmos usar o comando _insertOne_ várias vezes, vamos utilizar um novo comando. O comando _insertMany_, que nos permite inserir vários documentos de uma vez.

Da mesma forma, usaremos db e o nome da coleção antes do comando, no caso, a coleção será a de _membros_.

```bash
db.membros.insertMany([
  { nome: "Rodrigo Estagiário", dataNasc: "new DAte("1991-10-28")", sexo: "M", escola: "Eitor Freitas" },
  { nome: "João Estagiário", dataNasc: "new DAte("1992-12-13")", sexo: "M", escola: "Possidônio" },
  { nome: "Alysson Estagiário", dataNasc: "new DAte("1990-11-15")", sexo: "M", escola: "Possidônio" },
  { nome: "Bruna Estagiária", dataNasc: "new DAte("1995-12-26")", sexo: "F", escola: "Eitor Freitas" },
  { nome: "Aymin Estagiária", dataNasc: "new DAte("1990-08-28")", sexo: "F", escola: "Eitor Freitas" },
  { nome: "Nicole Estagiária", dataNasc: "new DAte("2000-03-27")", sexo: "F", escola: "Eitor Freitas" },
])
```

Rode novamente o comando _find_ para listar todos os membros. Não se esqueça de trocar a coleção para _membros_:

```bash
db.membros.find()

```

#### CRUD no **MongoDB**

Como todo bom tutorial de desenvolvimento web, é imprescindível termos um CRUD. Vamos realizar então um CRUD de livros.

##### CRUD de Livros

**Inserir um documento:**

```bash
db.livros.insertOne({titulo: "A Filha do Tempo e os Descendentes de Etherion", autor: "Rod Zandonadi", editora: "Griots", lancamento: new Date("2021-02-07")})
```

```bash
db.livros.insertOne({titulo: "O pior Rei Artur de todos os tempos", autor: "Rod Zandonadi", editora: "", lancamento: new Date("2021-02-07")})
```

Como vimos anteriormente, o comando _insertOne_ insere um documento na coleção especificada no **MongoDB**. Você pode usar _insertMany()_ para inserir vários documentos de uma vez:

```bash
db.membros.insertMany([
  {titulo: "A Filha do Tempo e as Armas Primervas", autor: "Rod Zandonadi", editora: "Griots", lancamento: new Date("2022-02-07")},
  {titulo: "A Filha do Tempo e os Escolhidos dos Primeiros", autor: "Rod Zandonadi", editora: "Griots", lancamento: new Date("2023-02-07")},
  {titulo: "Por Nidavellir", autor: "Rod Zandonadi", editora: "Griots", lancamento: new Date("2022-02-07")},
  {titulo: "Percy Jackson e o Último Olimpiano", autor: "Rick Riordan", editora: "Pendragon", lancamento: new Date("2023-07-12")}
])
```

**Consultar documentos no **MongoDB**:**

```bash
db.livros.find()
```

Já aprendemos o comando _find_ retorna todos os documentos na coleção especificada.

**Consultar documentos com filtro no **MongoDB**:**

```bash
db.nome_da_colecao.find({campo: valor})
```

Isso retorna os documentos que correspondem ao filtro especificado. Por exemplo, {editora: "Griots"} retornará os documentos com o campo *editora* igual a *Griots*.

```bash
db.livros.find({editora: "Griots"})
```

Podemos consultar também os autores:

```bash
db.livros.find({autor: "Rick Riordan"})
```

Ou qualquer outro campo que exista na coleção.

**Atualizar um documento no **MongoDB**:**

```bash
db.nome_da_colecao.updateOne({filtro}, {$set: {campo: novo_valor}})
```
Esse comando atualiza um documento que corresponda ao filtro especificado. Um uso comum é realizar a atualização pelo ID. Você pode pegar esse ID com o comando _find_, que lista todos os documentos da coleção. Vamos supor que você queria listar todos os livros da editora _Griots_:

```bash
db.livros.find({editora: "Griots"})
```
Agora é só escolher o documento que você quer atualizar, e inserir o valor do *_id* no comando _updateOne_. 

Para copiar o ID do terminal, selecione o ID, clique com o botão direito sobre a seleção e escolha _copiar_; ou, depois de selecionar o ID, aperte as teclas _CTRL + SHIFT + C_.

Para colar a informação no terminal, repita os passos anteriores, mas escolha _colar_ depois de clicar com o botão direito; e use _CTRL + SHIFT + V_ para colar.

```bash
db.livros.updateOne(
  { _id: ObjectId("id_do_documento") },
  { $set: { campo: novo_valor } }
)

```

 Use _updateMany()_ para atualizar vários documentos. Vamos supor que você queira adicionar o campo _ilustrador_ a todos os livros da editora _Griots_:

```bash
 db.minha_colecao.updateMany(
  { editora: "Griots" },
  { $set: { ilustrador: "Rodzanart" } }
)
```

**Excluir documentos no **MongoDB**:**

```bash
db.nome_da_colecao.deleteOne({filtro})
```

O comando _deleteOne_ exclui um documento que corresponda ao filtro especificado. Vamos criar um livro com o nome errado, e excluí-lo com base no nome.

```bash
db.livros.insertOne({titulo: "Livro para excluir", autor: "Rod Zandonadi", editora: "Forgus", lancamento: new Date("2021-02-07")})
```

E agora usaremos o comando _deleteOne_.

```bash
db.livros.deleteOne({ titulo: "Livro para excluir" })

```

Que tal confirmarmos com o comando _find_, filtrando pela editora _Forgus_?

```bash
db.livros.find({editora: "Forgus"})
```

Vamos usar insertMany para criar três livros e deletá-los usando _deleteMany()_.

```bash
db.membros.insertMany([
  {titulo: "Livro para excluir I", autor: "Rod Zandonadi", editora: "Forgus", lancamento: new Date("2022-02-07")},
  {titulo: "Livro para excluir II", autor: "Rod Zandonadi", editora: "Forgus", lancamento: new Date("2023-02-07")},
  {titulo: "Livro para excluir III", autor: "Rod Zandonadi", editora: "Forgus", lancamento: new Date("2022-02-07")},
])
```

```bash
db.minha_colecao.deleteMany({ editora: "Forgus" })
```

Falta agora conferir se todos os livros da editora _Forgus_ foram excluí-dos, com o comando _find_:

```bash
db.livros.find({editora: "Forgus"})
```

**Contar documentos no **MongoDB**:**

Esse é um bônus no nosso _CRUD_.

O comando _countDocuments_ retorna o número de documentos que correspondem ao filtro especificado.

```bash
db.minha_colecao.countDocuments({filtro})
```

Para saber quantos livros da editora _Griots_ temos em nosso sistema, basta usar o comando da seguinte forma:

```bash
db.livros.countDocuments({editora: "Griots"})
```

Esses são apenas alguns comandos básicos do **MongoDB** para começar. O ****MongoDB**** oferece uma ampla variedade de recursos e comandos avançados para manipulação de dados. Se vocês gostarem do artigo, trarei mais tutoriais para nos aprofundarmos no **MongoDB**.

Abração pessoal, e até a próxima.