Principais comandos do MongoDB

💬 Linguagem do MongoDB

O MongoDB usa, no seu shell interativo (mongosh), uma sintaxe baseada em JavaScript para escrever comandos e consultas.

Isso significa que, no dia a dia, você manipula coleções e documentos usando objetos e arrays no formato JSON (na verdade, o Mongo armazena em BSON – Binary JSON, otimizado para performance).
Por exemplo:

db.personagens.find({ nome: "Bob Esponja" })

Isso é JavaScript puro adaptado ao contexto do banco.

🎯 Finalidade principal de usar o MongoDB (NoSQL)

A grande proposta dele é ser:

Flexível → os dados são armazenados em documentos (JSON/BSON) sem precisar de esquema fixo como no SQL.
Escalável → fácil de lidar com grandes volumes de dados, inclusive distribuídos em vários servidores (sharding).
Ágil para desenvolvimento → mudanças na estrutura dos dados podem ser feitas rapidamente.
Ótimo para dados não estruturados ou semi-estruturados → como registros de usuários, logs, catálogos de produtos, conteúdo dinâmico de aplicações, etc.

Métodos de inserção no mongoDB

Os métodos de inserção mais comuns são:

insertOne() → insere um único documento
insertMany() → insere múltiplos documentos de uma vez

1️⃣ Inserindo um único documento (insertOne)

db.personagens.insertOne({
  nome: "Bob Esponja",
  ocupacao: "Cozinheiro",
  local: "Restaurante Siri Cascudo",
  idade: 20
})

2️⃣ Inserindo múltiplos documentos (insertMany)

db.personagens.insertMany([
  {
      nome: "Lula Molusco",
      ocupacao: "Atendente de Caixa",
      local: "Restaurante Siri Cascudo",
      idade: 45
  },
  {
      nome: "Patrick Estrela",
      ocupacao: "Desempregado",
      local: "Fenda do Biquíni",
      idade: 22
  },
  {
      nome: "Sandy Bochechas",
      ocupacao: "Cientista",
      local: "Domo de Vidro",
      idade: 25
  }
])

📌 Explicação rápida

db.<coleção> → indica a coleção onde os documentos serão inseridos (ex.: personagens).
insertOne() → um objeto por vez.
insertMany([]) → um array com vários objetos.
Não é obrigatório criar a coleção antes; o MongoDB cria automaticamente na primeira inserção.

🔍 Métodos de leitura no MongoDB

A função principal para leitura é find(), e ela tem algumas variações e parâmetros úteis.

1️⃣ Ler todos os documentos de uma coleção

db.personagens.find()

Retorna todos os documentos da coleção personagens.

2️⃣ Ler o primeiro documento encontrado

db.personagens.findOne()

Retorna apenas um documento (o primeiro que o banco encontrar).

3️⃣ Filtrar por campo específico

Ex.: encontrar todos que trabalham no "Restaurante Siri Cascudo":

db.personagens.find({ local: "Restaurante Siri Cascudo" })

Alguns operadores utilizados com find():

.limit() → limitar a quantidade de resultados

Mostrar apenas 2 personagens:

db.personagens.find().limit(2)

$or → “OU” lógico

Buscar quem trabalha no Siri Cascudo OU tem idade menor que 23:

db.personagens.find({
  $or: [
      { local: "Restaurante Siri Cascudo" },
      { idade: { $lt: 23 } }
  ]
})

$in → campo com valor dentro de uma lista

Buscar personagens que moram no Siri Cascudo ou no Domo de Vidro:

db.personagens.find({
  local: { $in: ["Restaurante Siri Cascudo", "Domo de Vidro"] }
})

$lt → menor que (less than)

Buscar personagens com idade menor que 25:

db.personagens.find({
  idade: { $lt: 25 }
})

$lte → menor ou igual (less than or equal)

Buscar personagens com idade menor ou igual a 25:

db.personagens.find({
  idade: { $lte: 25 }
})

Métodos de atualização no MongoDB

1️⃣ updateOne() → atualiza apenas o primeiro documento encontrado que corresponda ao filtro

Ex.: mudar a ocupação do Bob Esponja para “Gerente de Cozinha”:

db.personagens.updateOne(
  { nome: "Bob Esponja" },              // filtro
  { $set: { ocupacao: "Gerente de Cozinha" } } // atualização
)

2️⃣ updateMany() → atualiza todos os documentos que correspondam ao filtro

Ex.: aumentar a idade de todos que trabalham no Siri Cascudo em 1 ano:

db.personagens.updateMany(
  { local: "Restaurante Siri Cascudo" },
  { $inc: { idade: 1 } } // $inc incrementa valor numérico
)

3️⃣ replaceOne() → substitui um documento inteiro

Ex.: substituir completamente o registro do Patrick por um novo documento:

db.personagens.replaceOne(
  { nome: "Patrick Estrela" }, // filtro
  { 
      nome: "Patrick Estrela",
      ocupacao: "Influencer Submarino",
      local: "Fenda do Biquíni",
      idade: 23
  }
)

Aqui, se você não incluir um campo que existia antes, ele será removido no novo documento.

4️⃣ findOneAndUpdate() → atualiza e retorna o documento (por padrão, o original antes da alteração)

Ex.: mudar a ocupação da Sandy para “Inventora” e ver o documento atualizado:

db.personagens.findOneAndUpdate(
  { nome: "Sandy Bochechas" },
  { $set: { ocupacao: "Inventora" } },
  { returnDocument: "after" } // garante que retorne o documento após a atualização
)

🗑 Métodos de remoção no MongoDB

1️⃣ deleteOne() → remove apenas o primeiro documento que corresponde ao filtro

Ex.: remover o registro do Lula Molusco:

db.personagens.deleteOne(
  { nome: "Lula Molusco" } // filtro
)

Mesmo que existam vários documentos iguais, só o primeiro encontrado será deletado.

2️⃣ deleteMany() → remove todos os documentos que correspondam ao filtro

Ex.: deletar todos os personagens que moram no Balde de Lixo:

db.personagens.deleteMany(
  { local: "Balde de Lixo" }
)

3️⃣ findOneAndDelete() → encontra e retorna o documento removido

Ex.: deletar e ver os dados do Plankton antes da exclusão:

db.personagens.findOneAndDelete(
  { nome: "Plankton" }
)

Diferente dos outros métodos, ele devolve o documento removido, permitindo verificar o que foi apagado.

Fontes:

https://www.mongodb.com/pt-br/docs/mongodb-shell/run-commands/

https://www.mongodb.com/pt-br/docs/mongodb-shell/crud/insert/#std-label-mongosh-insert

https://www.mongodb.com/pt-br/docs/mongodb-shell/crud/read/#std-label-mongosh-read

https://www.mongodb.com/pt-br/docs/mongodb-shell/crud/update/#std-label-mongosh-update

https://www.mongodb.com/pt-br/docs/mongodb-shell/crud/delete/#std-label-mongosh-delete

Se quiser, posso te montar um comparativo rápido entre SQL e NoSQL pra você visualizar claramente quando faz sentido escolher um ou outro. Quer que eu faça, Erasmo?