Kako unosite, ažurirate i brišete dokumente?

Question

Accepted Answer

MongoDB mijenja podatke metodama za **unosenje** (`insertOne`/`insertMany`), **ažuriranje** (`updateOne`/`updateMany` s operatorima) i **brisanje** (`deleteOne`/`deleteMany`). Ažuriranja koriste **operatore za ažuriranje** umjesto zamjene cijelog dokumenta — važna je razlika.

## Unos

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

## Ažuriranje s operatorima (nemojte zamijeniti cijeli dokument)

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

**Važno:** ažuriranja koriste **operatore** (`$set`, `$inc`, `$push`, itd.) za izmjenu *određenih* polja. Bez operatora, *zamijenjujete cijeli dokument* — česti problem:

```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 } });
```

## Brisanje

```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 — unos ako nije pronađen

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

## Zašto je to važno

Operacije unosa, ažuriranja i brisanja predstavljaju način na koji aplikacije **mijenjaju podatke** u MongoDB-u, fundamentalno za sve podatkovne aplikacije, pa je razumijevanje istih nužno svakodnevno znanje.

Znanje o metodama (`insertOne`/`insertMany` za pravljenje, `updateOne`/`updateMany` za izmjenu, `deleteOne`/`deleteMany` za brisanje) pokriva osnove.

**Najvažnije i čest izvor greške** je što MongoDB ažuriranja koriste **operatore za ažuriranje** (`$set`, `$inc`, `$push`, `$pull`, itd.) za izmjenu *određenih* polja — i kritično, **zaboravljanje operatora zamjenjuje cijeli dokument** (poznat problem gdje `updateOne({...}, {age: 31})` briše sva ostala polja, ostavljajući samo `age`), tako da je razumijevanje da uvijek koristite `$set` (i ostale operatore) za ažuriranje na razini polja neophodno za ispravnost.

Znanje o čestim operatorima (`$set`, `$inc` za brojače, `$push`/`$pull`/`$addToSet` za nizove — operatori za nizove posebno važni jer su MongoDB dokumenti bogati nizovima) je važno svakodnevno znanje.

Razumijevanje **uperta** (`{ upsert: true }` — unos ako nema podudaranja, MongoDB-ov insert-ili-ažuriraj) je vrijedno za čest uzorak unosa-ili-ažuriranja.

Također je vrijedno napomenuti opasnost od `deleteMany({})` (brisanja svega — slično kao nedostaju WHERE opasnost u SQL-u).

Budući da je izmjena podataka fundamentalna, a MongoDB-ova ažuriranja s operatorima (s rizikom od zamjene dokumenta), operatori za nizove i upsert su način na koji ispravno mijenjate podatke, razumijevanje unosa/ažuriranja/brisanja — posebno kritična razlika vezana uz operatore ažuriranja (izbjegavanje slučajne zamjene dokumenta) — je nužno, obavezno znanje za bilo koji MongoDB razvoj, gdje je problem s operatorima posebno čest izvor stvarnih grešaka.