Come si inseriscono, aggiornano ed eliminano documenti?

Question

Accepted Answer

MongoDB modifica i dati con i metodi **insert** (`insertOne`/`insertMany`), **update** (`updateOne`/`updateMany` con operatori) e **delete** (`deleteOne`/`deleteMany`). Gli aggiornamenti utilizzano **operatori di aggiornamento** piuttosto che sostituire interi documenti — una distinzione importante.

## Insert

```js
db.users.insertOne({ name: "Ann", age: 30 });          // → returns the inserted _id
db.users.insertMany([{ name: "Bob" }, { name: "Carol" }]);   // bulk insert (efficient)
```

## Update con operatori (non sostituire l'intero documento)

```js
// updateOne — filter (which doc) + update (with OPERATORS)
db.users.updateOne(
  { name: "Ann" },
  { $set: { age: 31, status: "active" } }   // $set: change specific fields
);

// common update operators
{ $set: { field: value } }       // set/change a field
{ $unset: { field: "" } }         // remove a field
{ $inc: { count: 1 } }            // increment a number
{ $push: { tags: "new" } }        // add to an array
{ $pull: { tags: "old" } }        // remove from an array
{ $addToSet: { tags: "x" } }      // add to array only if not present
```

```js
db.users.updateMany({ active: false }, { $set: { archived: true } });  // update all matching
```

**Importante:** gli aggiornamenti utilizzano **operatori** (`$set`, `$inc`, `$push`, ecc.) per modificare campi *specifici*. Senza un operatore, sostituiresti l'*intero documento* — un errore comune:

```js
// ❌ this REPLACES the whole document (loses other fields!)
db.users.updateOne({ name: "Ann" }, { age: 31 });   // Ann now has ONLY age!
// ✅ use $set to change just the field
db.users.updateOne({ name: "Ann" }, { $set: { age: 31 } });
```

## Delete

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

## Upsert — inserire se non trovato

```js
db.users.updateOne(
  { email: "ann@x.com" },
  { $set: { name: "Ann" } },
  { upsert: true }            // if no match, INSERT a new document
);
```

## Perché è importante

Le operazioni di inserimento, aggiornamento ed eliminazione sono come le applicazioni **modificano i dati** in MongoDB, fondamentali per qualsiasi applicazione orientata ai dati, quindi comprenderle è una conoscenza essenziale quotidiana.

Conoscere i metodi (`insertOne`/`insertMany` per creare, `updateOne`/`updateMany` per modificare, `deleteOne`/`deleteMany` per rimuovere) copre le nozioni di base.

Il **punto più importante e comunemente frainteso** è che gli aggiornamenti di MongoDB utilizzano **operatori di aggiornamento** (`$set`, `$inc`, `$push`, `$pull`, ecc.) per modificare campi *specifici* — e crucialmente, **dimenticare l'operatore sostituisce l'intero documento** (un errore notorio dove `updateOne({...}, {age: 31})` cancella tutti gli altri campi, lasciando solo `age`), quindi comprendere di utilizzare sempre `$set` (e gli altri operatori) per aggiornamenti a livello di campo è essenziale per la correttezza.

Conoscere gli operatori comuni (`$set`, `$inc` per contatori, `$push`/`$pull`/`$addToSet` per array — gli operatori array essendo particolarmente rilevanti dato i documenti ricchi di array di MongoDB) è una conoscenza importante quotidiana.

Comprendere **upsert** (`{ upsert: true }` — inserire se non esiste una corrispondenza, l'insert-or-update di MongoDB) è prezioso per il comune pattern insert-or-update.

Vale anche la pena notare il pericolo di `deleteMany({})` (eliminare tutto — simile al pericolo del WHERE mancante in SQL).

Poiché modificare i dati è fondamentale, e poiché gli aggiornamenti basati su operatori di MongoDB (con il pitfall della sostituzione del documento), gli operatori array e upsert sono come correttamente cambiate i dati, comprendere insert/update/delete — specialmente la distinzione critica dell'operatore di aggiornamento (evitando la sostituzione accidentale del documento) — è una conoscenza essenziale e imprescindibile per qualsiasi sviluppo MongoDB, dove il pitfall dell'operatore in particolare è una fonte frequente di bug reali.