நீங்கள் எவ்வாறு ஆவணங்களை செருகுவது, புதுப்பிப்பது மற்றும் நீக்குவது?

Question

Accepted Answer

MongoDB வேறுபட்ட தரவுக்களை **insert** (`insertOne`/`insertMany`), **update** (`updateOne`/`updateMany` operators உடன்), மற்றும் **delete** (`deleteOne`/`deleteMany`) முறைகளுடன் மாற்றுகிறது. புதுப்பிப்புகள் முழு ஆவணங்களை மாற்றுவதற்குப் பதிலாக **update operators** ஐப் பயன்படுத்துகின்றன — இது ஒரு முக்கியமான வேறுபாடாகும்.

## Insert

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

## Operators உடன் Update (முழு 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
```

**முக்கியமானது:** புதுப்பிப்புகள் **operators** (`$set`, `$inc`, `$push`, முதலியன) ஐப் பயன்படுத்தி *குறிப்பிட்ட* புலங்களை மாற்றுகின்றன. Operator இல்லாமல், நீங்கள் *முழு ஆவணத்தையும் மாற்றுவீர்கள்* — இது ஒரு பொதுவான பிழையாகும்:

```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 புதுப்பிப்புகள் **update operators** (`$set`, `$inc`, `$push`, `$pull`, முதலியன) ஐப் பயன்படுத்தி *குறிப்பிட்ட* புலங்களை மாற்றுகின்றன — மற்றும் முக்கியமாக, **operator ஐ மறந்துவிடுவது முழு ஆவணத்தையும் மாற்றுகிறது** (ஒரு பெயரெண்ணப்பட்ட பிழை இதில் `updateOne({...}, {age: 31})` அனைத்து வேறு புலங்களையும் அழிக்கிறது, `age` மட்டும் விட்டுச்செல்கிறது), எனவே எப்போதும் புல-நிலை புதுப்பிப்புகளுக்கு `$set` (மற்றும் மற்ற operators) ஐப் பயன்படுத்த மனதுவைத்துக்கொள்வது சரியான தன்மைக்கு அপরिहार्যமாகும்.

பொதுவான operators தெரிந்துகொள்வது (`$set`, `$inc` counters க்கு, `$push`/`$pull`/`$addToSet` arrays க்கு — array operators خصوصی MongoDB இன் array-rich ஆவணங்களைக் கொடுத்ததாக) அன்றாட முக்கியமான அறிவாகும்.

**upsert** புரிந்துகொள்வது (`{ upsert: true }` — பொருத்தம் இல்லாவிட்டால் செருகவும், MongoDB இன் insert-or-update) பொதுவான insert-or-update வடிவத்திற்கு மதிப்புள்ளது.

இதுவும் குறிப்பிடத்தக்க விஷயம் `deleteMany({})` இன் ஆபத்து (அனைத்தையும் நீக்குவது — SQL இல் missing-WHERE ஆபத்தைப் போன்றது).

தரவுகளை மாற்றுவது அடிப்படையான விஷயம் என்பதாக உள்ளதால், மற்றும் MongoDB இன் operator-based புதுப்பிப்புகள் (ஆவண-மாற்றம் பிழையுடன்), array operators, மற்றும் upsert என்பது தரவுகளை சரியாக மாற்றுவதற்கான முறைகளாக உள்ளதால், insert/update/delete ஐ புரிந்துகொள்வது — குறிப்பாக முக்கியமான update-operator வேறுபாடு (தற்செயலான ஆவண-மாற்றம் தவிர்ப்பது) — அপরिहार्य, MongoDB மேம்பாட்டிற்கான தெரிந்து கொள்ள வேண்டிய அறிவாகும், இதில் operator பிழை குறிப்பாக உண்மையான பிழைகளின் அடிக்கடி மூலமாகும்.