Dominando as Operações CRUD do MongoDB: Um Guia Prático de Comandos

O MongoDB, um popular banco de dados de documentos NoSQL, é a espinha dorsal de inúmeras aplicações modernas devido à sua flexibilidade, escalabilidade e desempenho. No cerne da interação com qualquer banco de dados estão as operações fundamentais de Criar, Ler, Atualizar e Excluir (CRUD).

Dominar esses comandos é essencial para quem trabalha com MongoDB, desde desenvolvedores que criam novos recursos até administradores que gerenciam dados.

Este guia abrangente irá guiá-lo pelos comandos principais do MongoDB para executar operações CRUD. Cobriremos os comandos insert, find, update e delete com exemplos práticos e fáceis de entender, equipando você com o conhecimento para gerenciar seus dados com eficiência. Ao final deste artigo, você terá uma compreensão sólida de como interagir com suas coleções do MongoDB de forma eficaz e confiante.

Pré-requisitos

Antes de mergulhar nos comandos, certifique-se de ter:

• MongoDB instalado e em execução: Você pode baixá-lo no site oficial do MongoDB ou usar um serviço em nuvem como o MongoDB Atlas.
• mongosh (MongoDB Shell) instalado: Esta é a interface interativa em JavaScript para o MongoDB.

Conectando-se ao MongoDB e Selecionando um Banco de Dados

Para começar, abra seu terminal ou prompt de comando e conecte-se à sua instância do MongoDB usando mongosh:

mongosh

Uma vez conectado, você estará no banco de dados padrão test. Para mudar ou criar um novo banco de dados, use o comando use:

use myDatabase;

Se myDatabase não existir, o MongoDB o criará implicitamente quando você inserir seu primeiro documento em uma coleção dentro dele.

Operações de Criação (Inserir)

As operações de criação envolvem adicionar novos documentos a uma coleção. O MongoDB fornece métodos para inserir um ou vários documentos.

1. db.collection.insertOne()

Este método insere um único documento em uma coleção. Se a coleção não existir, o MongoDB a criará.

// Seleciona uma coleção chamada 'users'
db.users.insertOne({
  name: "Alice Smith",
  age: 30,
  city: "New York",
  email: "[email protected]",
  interests: ["reading", "hiking"]
});

A saída mostrará o status acknowledged (reconhecido) e o insertedId (ID inserido) do novo documento.

2. db.collection.insertMany()

Use este método para inserir vários documentos em uma coleção em uma única operação. Ele aceita um array de documentos.

db.users.insertMany([
  {
    name: "Bob Johnson",
    age: 24,
    city: "Los Angeles",
    email: "[email protected]",
    interests: ["coding", "gaming"]
  },
  {
    name: "Charlie Brown",
    age: 35,
    city: "New York",
    email: "[email protected]",
    interests: ["cooking", "photography"]
  },
  {
    name: "Diana Prince",
    age: 29,
    city: "London",
    email: "[email protected]",
    interests: ["fitness", "travel"]
  }
]);

Isso retornará um array de insertedIds para todos os documentos adicionados.

Dica: O MongoDB adiciona automaticamente um campo _id (um ObjectId exclusivo) a cada documento se você não fornecer um.

Operações de Leitura (Find)

As operações de leitura envolvem consultar documentos de uma coleção. O método find() é sua principal ferramenta para isso.

1. db.collection.find()

a. Encontrar Todos os Documentos

Para recuperar todos os documentos em uma coleção, chame find() sem argumentos:

db.users.find();

b. Encontrar Documentos com um Filtro de Consulta

Passe um documento de consulta para find() para especificar critérios de seleção de documentos. Isso atua como uma cláusula WHERE no SQL.

// Encontra usuários de Nova York
db.users.find({ city: "New York" });

// Encontra usuários com mais de 25 anos
db.users.find({ age: { $gt: 25 } });

// Encontra usuários com idade entre 25 e 35 (excluindo 35)
db.users.find({ age: { $gt: 25, $lt: 35 } });

// Encontra usuários cujos interesses incluem 'coding'
db.users.find({ interests: "coding" });

// Encontra usuários cujos interesses incluem AMBOS 'reading' e 'hiking'
db.users.find({ interests: { $all: ["reading", "hiking"] } });

// Encontra usuários chamados Alice Smith OU da cidade de Londres
db.users.find({
  $or: [
    { name: "Alice Smith" },
    { city: "London" }
  ]
});

Operadores de consulta comuns:
* $eq: Igual a (padrão se nenhum operador for especificado)
* $ne: Diferente de
* $gt: Maior que
* $gte: Maior ou igual a
* $lt: Menor que
* $lte: Menor ou igual a
* $in: Corresponde a qualquer um dos valores especificados em um array
* $nin: Não corresponde a nenhum dos valores especificados em um array
* $and, $or, $not, $nor: Operadores lógicos

c. Projeção: Selecionando Campos Específicos

Para retornar apenas um subconjunto de campos, passe um documento de projeção como o segundo argumento para find(). Um valor de 1 inclui o campo, 0 o exclui. O campo _id é incluído por padrão, a menos que explicitamente excluído.

// Retorna apenas o nome e e-mail, exclui _id
db.users.find({ city: "New York" }, { name: 1, email: 1, _id: 0 });

d. Ordenação, Limitação e Pulo (Skipping)

Encadear métodos permite consultas mais complexas:

// Ordena por idade em ordem decrescente (1 para crescente, -1 para decrescente)
db.users.find().sort({ age: -1 });

// Limita os resultados a 2 documentos
db.users.find().limit(2);

// Pula os 2 primeiros documentos e retorna o restante
db.users.find().skip(2);

// Combina operações: Encontra usuários de Nova York, ordena por idade, pula 1, limita 1
db.users.find({ city: "New York" }).sort({ age: 1 }).skip(1).limit(1);

2. db.collection.findOne()

Este método retorna um único documento que corresponde aos critérios da consulta. Se vários documentos corresponderem, ele retorna o primeiro encontrado.

db.users.findOne({ name: "Alice Smith" });

Operações de Atualização

As operações de atualização modificam documentos existentes em uma coleção. Você pode atualizar um único documento, vários documentos ou até mesmo substituir um documento inteiro.

1. db.collection.updateOne()

Atualiza um único documento que corresponde aos critérios do filtro.

// Atualiza a cidade de Alice para 'San Francisco'
db.users.updateOne(
  { name: "Alice Smith" },
  { $set: { city: "San Francisco", lastUpdated: new Date() } }
);

2. db.collection.updateMany()

Atualiza todos os documentos que correspondem aos critérios do filtro.

// Incrementa a idade de todos os usuários em Nova York em 1
db.users.updateMany(
  { city: "New York" },
  { $inc: { age: 1 } }
);

// Adiciona um novo interesse 'reading' aos usuários que ainda não o possuem
db.users.updateMany(
  {}, // Aplica a todos os documentos
  { $addToSet: { interests: "reading" } }
);

// Remove 'gaming' dos interesses de Bob Johnson
db.users.updateOne(
  { name: "Bob Johnson" },
  { $pull: { interests: "gaming" } }
);

Operadores de Atualização Comuns:
* $set: Define o valor de um campo em um documento. Cria o campo se ele não existir.
* $inc: Incrementa o valor de um campo por um valor especificado.
* $unset: Remove um campo de um documento.
* $push: Anexa um valor a um campo de array.
* $pull: Remove todas as instâncias de um valor ou valores que correspondem a uma consulta especificada de um array.
* $addToSet: Adiciona um valor a um array somente se o valor ainda não estiver presente.

3. db.collection.replaceOne()

Substitui um único documento que corresponde aos critérios do filtro por um novo documento. O campo _id do documento substituído não pode ser alterado.

// Substitui completamente o documento de Bob Johnson
db.users.replaceOne(
  { name: "Bob Johnson" },
  {
    name: "Robert Johnson",
    occupation: "Software Engineer",
    status: "active",
    email: "[email protected]"
  }
);

Opção Upsert

Tanto updateOne() quanto updateMany() suportam uma opção upsert. Se definida como true, e nenhum documento corresponder ao filtro, o MongoDB inserirá um novo documento baseado nas operações de consulta e atualização.

db.users.updateOne(
  { name: "David Lee" },
  { $set: { age: 28, city: "Seattle" } },
  { upsert: true } // Se David Lee não existir, ele é criado
);

Operações de Exclusão

As operações de exclusão removem documentos de uma coleção. Tenha extremo cuidado com as operações de exclusão, pois elas são irreversíveis.

1. db.collection.deleteOne()

Exclui no máximo um documento que corresponde ao filtro especificado.

// Exclui o usuário chamado 'Robert Johnson' (anteriormente 'Bob Johnson')
db.users.deleteOne({ name: "Robert Johnson" });

2. db.collection.deleteMany()

Exclui todos os documentos que correspondem ao filtro especificado.

// Exclui todos os usuários de Londres
db.users.deleteMany({ city: "London" });

Aviso: Para excluir todos os documentos em uma coleção, use um filtro vazio {}. Tenha extremo cuidado, pois esta operação não pode ser desfeita:

javascript db.users.deleteMany({}); // Exclui todos os documentos na coleção 'users'

3. db.collection.drop()

Este método remove permanentemente uma coleção inteira do banco de dados, incluindo todos os seus documentos e índices.

db.users.drop(); // Exclui toda a coleção 'users'

Aviso: Excluir uma coleção é uma operação altamente destrutiva. Certifique-se de ter backups adequados ou esteja absolutamente certo antes de executar este comando.

Melhores Práticas para CRUD no MongoDB

• Indexação: Para campos consultados frequentemente, crie índices para acelerar significativamente as operações de leitura. db.collection.createIndex({ fieldName: 1 }).
• Projeções: Recupere apenas os dados de que você precisa. Usar projeções ({ field: 1 }) reduz a largura de banda da rede e o uso de memória.
• Operações em Lote: Ao inserir, atualizar ou excluir muitos documentos, use insertMany(), updateMany() e deleteMany() em vez de operações individuais para reduzir a sobrecarga.
• Entenda os Operadores: Familiarize-se com o rico conjunto de operadores de consulta e atualização do MongoDB. Eles oferecem maneiras poderosas de manipular seus dados.
• Tratamento de Erros: Em uma aplicação de produção, sempre implemente tratamento de erros robusto para suas operações de banco de dados.
• Design de Esquema: Embora o MongoDB seja 'schema-less' (sem esquema fixo), um design de esquema atencioso é crucial para consultas eficientes e consistência dos dados.

Conclusão

Dominar as operações CRUD do MongoDB é fundamental para o gerenciamento eficaz de dados e desenvolvimento de aplicações. Este guia forneceu um passo a passo prático dos comandos essenciais de insert, find, update e delete, completos com exemplos e melhores práticas.

Ao entender como criar, ler, atualizar e excluir documentos, você adquiriu as habilidades básicas para interagir com seus bancos de dados MongoDB de forma eficiente. Continue praticando esses comandos e explorando recursos mais avançados, como pipelines de agregação, transações e estratégias de indexação, para aprimorar ainda mais sua experiência com o MongoDB.