როგორ იტავსებთ, განაახლებთ და წაშლით დოკუმენტებს?

Question

Accepted Answer

MongoDB ასწორებს მონაცემებს **insert** (`insertOne`/`insertMany`), **update** (`updateOne`/`updateMany` ოპერატორებით) და **delete** (`deleteOne`/`deleteMany`) მეთოდებით. განახლებები იყენებენ **update ოპერატორებს**, რათა არ შეცვალონ მთელი დოკუმენტი — ეს მნიშვნელოვანი განსხვავებაა.

## Insert

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

## Update ოპერატორებით (მთელი დოკუმენტის ჩანაცვლება არ გააკეთოთ)

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

**მნიშვნელოვანი:** განახლებები იყენებენ **ოპერატორებს** (`$set`, `$inc`, `$push` და სხვა) კონკრეტული ველების შესაცვლელად. ოპერატორის გარეშე თქვენ *მთელ დოკუმენტს ჩანაცვლებდით* — ეს ხშირი შეცდომაა:

```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 — insert თუ ვერ მოიძებნა

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

## რატომ მნიშვნელოვანია

Insert, update და delete ოპერაციები არის ის, როგორ **ასწორებს MongoDB მონაცემებს**, რაც ფუნდამენტური ყველა მონაცემებით მოქმედი აპლიკაციისთვის, ამიტომ მათი გაგება აუცილებელია ყოველდღიური სამუშაოსთვის.

მეთოდების ცოდნა (`insertOne`/`insertMany` შესაქმნელად, `updateOne`/`updateMany` შესაცვლელად, `deleteOne`/`deleteMany` წასაშლელად) ფუნდამენტურს მოიცავს.

**ყველაზე მნიშვნელოვანი და ხშირად გაუცხოებული პუნქტი** ის არის, რომ MongoDB განახლებები იყენებენ **update ოპერატორებს** (`$set`, `$inc`, `$push`, `$pull` და სხვა) კონკრეტული ველების შესაცვლელად — და უმნიშვნელოვანესი, **ოპერატორის დამ健忘 მთელ დოკუმენტს ჩანაცვლებს** (სახელმწიფო შეცდომა სადაც `updateOne({...}, {age: 31})` წაშლის ყველა სხვა ველს, დატოვებს მხოლოდ `age`-ს), ამიტომ მნიშვნელოვანია ყოველთვის გამოიყენოთ `$set` (და სხვა ოპერატორები) ველების დონის განახლებებისთვის სისწორის უზრუნველსაყოფად.

ჩვეულებრივი ოპერატორების ცოდნა (`$set`, `$inc` მრიცხველებისთვის, `$push`/`$pull`/`$addToSet` მასივებისთვის — მასივის ოპერატორები განსაკუთრებით შესაბამისი MongoDB-ის მასივებით მდიდარი დოკუმენტების გამო) არის მნიშვნელოვანი ყოველდღიური ცოდნა.

**upsert**-ის გაგება (`{ upsert: true }` — insert თუ კოპ განხორციელდა, MongoDB-ის insert-ან-update) ღირებული არის ჩვეულებრივი insert-ან-update ნიმუშისთვის.

ასევე შესაბამისი აღსენებაა `deleteMany({})`-ის საფრთხე (ყველაფრის წაშლა — SQL-ში missing-WHERE ძალას მსგავსი).

ვინაიდან მონაცემების შეცვლა ფუნდამენტურია, და ვინაიდან MongoDB-ის ოპერატორზე დაფუძნებული განახლებები (დოკუმენტის ჩანაცვლების საფრთხეთი), მასივის ოპერატორები და upsert წარმოადგენენ როგორ სწორად შეცვალოთ მონაცემები, insert/update/delete-ის გაგება — განსაკუთრებით კრიტიკული update-ოპერატორის განსხვავება (შემთხვევითი დოკუმენტის ჩანაცვლების თავიდან აცილება) — აუცილებელი, არასავარაუდო ცოდნა ნებისმიერი MongoDB განვითარების უზრუნველსაყოფად, სადაც ოპერატორის საფრთხე განსაკუთრებით არის რეალური ხარვეზების ხშირი წყარო.