Como funcionam as operações CRUD no MongoDB?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) são operações no MongoDB que usam métodos em coleções. Elas funcionam com documentos e usam uma sintaxe de consulta flexível, semelhante a JSON — diferente de SQL, mas conceitualmente similar.

## Create — inserir documentos

```js
db.users.insertOne({ name: "Ann", age: 30 });          // insert one document
db.users.insertMany([                                   // insert multiple
  { name: "Bob", age: 25 },
  { name: "Carol", age: 28 }
]);
// each gets an auto-generated _id if not provided
```

## Read — consultar documentos

```js
db.users.find();                              // all documents
db.users.find({ age: 30 });                   // WHERE age = 30 (a query filter object)
db.users.find({ age: { $gt: 25 } });          // age > 25 ($gt operator)
db.users.findOne({ name: "Ann" });            // the first match
db.users.find({ active: true }, { name: 1 }); // projection — return only the name field
```

As consultas usam um **documento de filtro** (`{ field: value }`) descrevendo o que procurar, com operadores (`$gt`, `$lt`, `$in`, etc.) para condições. Projeção (`{ name: 1 }`) seleciona quais campos retornar.

## Update — modificar documentos

```js
// updateOne/updateMany with UPDATE OPERATORS ($set, $inc, etc.)
db.users.updateOne(
  { name: "Ann" },                  // filter — which document
  { $set: { age: 31 } }              // update — $set changes a field
);
db.users.updateMany(
  { active: false },
  { $set: { status: "inactive" } }   // update all matching
);
db.users.updateOne({ name: "Ann" }, { $inc: { loginCount: 1 } });  // increment
```

Atualizações recebem um **filtro** (quais documentos) e um **documento de atualização** usando **operadores** como `$set` (define um campo), `$inc` (incrementa), `$push` (adiciona a um array) — você não substitui o documento inteiro (a menos que pretendido).

## Delete — remover documentos

```js
db.users.deleteOne({ name: "Ann" });          // delete the first match
db.users.deleteMany({ active: false });        // delete all matching
```

## Por que isso importa

Operações CRUD são a base de trabalhar com qualquer banco de dados, então entender como funcionam no MongoDB é conhecimento essencial do dia a dia para usá-lo.

As operações — **inserir** documentos (`insertOne`/`insertMany`), **consultar** com documentos de filtro e operadores (`find`/`findOne` com filtros `{ field: value }`, operadores de comparação como `$gt`, e projeções para selecionar campos), **atualizar** com filtros e operadores de atualização (`updateOne`/`updateMany` com `$set`, `$inc`, etc.), e **deletar** (`deleteOne`/`deleteMany`) — são como aplicações criam, leem, modificam e removem dados no MongoDB, que é o cerne da maioria das interações com banco de dados.

Entender a abordagem distintiva do MongoDB é importante: consultas usam um **documento de filtro** (um objeto semelhante a JSON descrevendo o que procurar, com operadores) em vez da sintaxe `WHERE` do SQL, e atualizações usam **operadores de atualização** (`$set` para alterar campos, `$inc` para incrementar, `$push` para arrays) em vez de substituição de documento inteiro — um modelo diferente, mas aprendível.

Como CRUD é a operação fundamental e constante em qualquer aplicação orientada a dados, e como os métodos CRUD do MongoDB, consultas com documento de filtro e operadores de atualização são como você interage com o banco de dados diariamente, entender as operações CRUD do MongoDB — os métodos, a sintaxe de consulta com filtro/operador e os operadores de atualização — é conhecimento essencial e obrigatório para qualquer desenvolvimento MongoDB, o equivalente de conhecer SELECT/INSERT/UPDATE/DELETE para SQL e a base prática para trabalhar com o banco de dados.