Come funzionano le operazioni CRUD in MongoDB?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) sono operazioni in MongoDB che usano metodi sulle collezioni. Lavorano con documenti e usano una sintassi di query flessibile, simile a JSON — diversa da SQL ma concettualmente simile.

## Create — inserire documenti

```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 — interrogare documenti

```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
```

Le query usano un **documento di filtro** (`{ field: value }`) che descrive cosa cercare, con operatori (`$gt`, `$lt`, `$in`, ecc.) per le condizioni. La proiezione (`{ name: 1 }`) seleziona quali campi restituire.

## Update — modificare documenti

```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
```

Gli aggiornamenti richiedono un **filtro** (quali documenti) e un **documento di aggiornamento** che usa **operatori** come `$set` (impostare un campo), `$inc` (incrementare), `$push` (aggiungere a un array) — non sostituisci l'intero documento (a meno che non sia intenzionale).

## Delete — rimuovere documenti

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

## Perché è importante

Le operazioni CRUD sono il fondamento del lavoro con qualsiasi database, quindi comprendere come funzionano in MongoDB è una conoscenza essenziale e quotidiana per usarlo.

Le operazioni — **inserire** documenti (`insertOne`/`insertMany`), **interrogare** con documenti di filtro e operatori (`find`/`findOne` con filtri `{ field: value }`, operatori di confronto come `$gt`, e proiezioni per selezionare campi), **aggiornare** con filtri e operatori di aggiornamento (`updateOne`/`updateMany` con `$set`, `$inc`, ecc.), e **eliminare** (`deleteOne`/`deleteMany`) — sono come le applicazioni creano, leggono, modificano e rimuovono dati in MongoDB, che è il nucleo della maggior parte dell'interazione con il database.

Comprendere l'approccio distintivo di MongoDB è importante: le query usano un **documento di filtro** (un oggetto simile a JSON che descrive cosa cercare, con operatori) piuttosto che la sintassi `WHERE` di SQL, e gli aggiornamenti usano **operatori di aggiornamento** (`$set` per modificare campi, `$inc` per incrementare, `$push` per gli array) piuttosto che la sostituzione dell'intero documento — un modello diverso ma facilmente apprendibile.

Poiché CRUD è l'operazione fondamentale e costante in qualsiasi applicazione basata su dati, e poiché i metodi CRUD di MongoDB, le query con documento di filtro e gli operatori di aggiornamento sono il modo in cui interagisci con il database ogni giorno, comprendere le operazioni CRUD di MongoDB — i metodi, la sintassi di query con filtro/operatore e gli operatori di aggiornamento — è una conoscenza essenziale e imprescindibile per qualsiasi sviluppo con MongoDB, l'equivalente di conoscere SELECT/INSERT/UPDATE/DELETE per SQL e il fondamento pratico per lavorare con il database.