మీరు డాక్యుమెంట్‌లను ఎలా చేర్చుకుంటారు, నవీకరించుకుంటారు మరియు తొలగిస్తారు?

Question

Accepted Answer

MongoDB **insert** (`insertOne`/`insertMany`), **update** (`updateOne`/`updateMany` ఆపరేటర్‌లతో), మరియు **delete** (`deleteOne`/`deleteMany`) పద్ధతులతో డేటాను సవరిస్తుంది. నవీకరణలు **అప్‌డేట్ ఆపరేటర్‌లను** ఉపయోగిస్తాయి మొత్తం డాక్యుమెంట్‌లను భర్తీ చేయడానికి బదులుగా — ఇది ఒక ముఖ్యమైన వ్యత్యాసం.

## Insert

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

## Update with operators (don't replace the whole doc)

```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 — కనుగొనబడకపోతే చేర్చుకోండి

```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 నవీకరణలు **అప్‌డేట్ ఆపరేటర్‌లను** (`$set`, `$inc`, `$push`, `$pull`, మొదలైనవి) *నిర్దిష్ట* ఫీల్డ్‌లను సవరించడానికి ఉపయోగిస్తాయి — మరియు కీలకంగా, **ఆపరేటర్‌ను మరచిపోవడం మొత్తం డాక్యుమెంట్‌ను భర్తీ చేస్తుంది** (కुఖ్యాతపూర్వక ఆపద్ర ఎక్కడ `updateOne({...}, {age: 31})` అన్ని ఇతర ఫీల్డ్‌లను తుడిచివేస్తుంది, కేవలం `age` మిగిలి ఉంటుంది), కాబట్టి ఎల్లప్పుడు `$set` (మరియు ఇతర ఆపరేటర్‌లు) ఫీల్డ్-స్థాయి నవీకరణల కోసం ఉపయోగించటానికి అర్థం చేసుకోవడం సరిభద్రతకు ఆవశ్యకమైనది.

సాధారణ ఆపరేటర్‌లను తెలుసుకోవడం (`$set`, `$inc` కাউంటర్‌ల కోసం, `$push`/`$pull`/`$addToSet` శ్రేణులకు — శ్రేణి ఆపరేటర్‌లు MongoDB యొక్క శ్రేణి-సমృద్ధ డాక్యుమెంట్‌ల కారణంగా ప్రత్యేకంగా సంబంధితమైనవి) రోజువారీ ముఖ్యమైన జ్ఞానం.

**Upsert** అర్థం చేసుకోవడం (`{ upsert: true }` — సరిపోలిక లేనట్లయితే చేర్చుకోండి, MongoDB యొక్క insert-or-update) సాధారణ insert-or-update నమూనার కోసం విలువైనది.

`deleteMany({})` యొక్క ప్రమాదం కూడా గమనించదగ్గది (ప్రతిదాన్ని తొలగిస్తుంది — SQL లో missing-WHERE ప్రమాదానికి సమానమైనది).

డేటాను సవరించడం ఆధారమైనది కనుక, మరియు MongoDB యొక్క ఆపరేటర్-ఆధారిత నవీకరణలు (డాక్యుమెంట్-భర్తీ ఆపద్ర), శ్రేణి ఆపరేటర్‌లు, మరియు upsert మీరు డేటాను సరిగ్గా ఎలా మార్చాలో, insert/update/delete అర్థం చేసుకోవడం — ముఖ్యంగా క్రిటికల్ update-operator వ్యత్యాసం (ఆకస్మిక డాక్యుమెంట్ భర్తీ నివారించడం) — MongoDB అభివృద్ధి కోసం ఆవశ్యకమైన, తప్పనిసరి-తెలుసుకోవాల్సిన జ్ఞానం, ఇక్కడ ఆపరేటర్ ఆపద్ర ఖాస్తుగా నిజమైన బగ్‌ల యొక్క తరచైన కారణం.