MongoDB இல் CRUD செயல்பாடுகள் எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) செயல்பாடுகள் MongoDB இல் சேகரणங்களில் உள்ள முறைகளைப் பயன்படுத்துகின்றன. அவை ஆவணங்களுடன் செயல்படுகின்றன மற்றும் நমনीய, JSON ஆன்மாவான கேள்வி தொடரியலைப் பயன்படுத்துகின்றன — SQL இலிருந்து வேறுபட்டது ஆனால் கருத்தளவில் ஒத்திருக்கிறது.

## Create — ஆவணங்களைச் சேர்க்கவும்

```js
db.users.insertOne({ name: "Ann", age: 30 });          // insert one document
db.users.insertMany([                                   // insert multiple
  { name: "Bob", age: 25 },
  { name: "Carol", age: 28 }
]);
// each gets an auto-generated _id if not provided
```

## Read — ஆவணங்களைக் கேள்வி செய்யவும்

```js
db.users.find();                              // all documents
db.users.find({ age: 30 });                   // WHERE age = 30 (a query filter object)
db.users.find({ age: { $gt: 25 } });          // age > 25 ($gt operator)
db.users.findOne({ name: "Ann" });            // the first match
db.users.find({ active: true }, { name: 1 }); // projection — return only the name field
```

கேள்விகள் **வடிகட்டல் ஆவணத்தைப்** (`{ field: value }`) பயன்படுத்துகின்றன, இது எது பொருந்த வேண்டும் என்பதை விவரிக்கிறது, நிபந்தனைகளுக்கான ஆபரேட்டர்கள் (`$gt`, `$lt`, `$in`, முதலியன) உடன். முன்வைப்பு (`{ name: 1 }`) எந்த புலங்கள் திரும்ப வேண்டும் என்பதைத் தேர்ந்தெடுக்கிறது.

## Update — ஆவணங்களைத் திருத்தவும்

```js
// updateOne/updateMany with UPDATE OPERATORS ($set, $inc, etc.)
db.users.updateOne(
  { name: "Ann" },                  // filter — which document
  { $set: { age: 31 } }              // update — $set changes a field
);
db.users.updateMany(
  { active: false },
  { $set: { status: "inactive" } }   // update all matching
);
db.users.updateOne({ name: "Ann" }, { $inc: { loginCount: 1 } });  // increment
```

আপডேட்டுகள் **வடிகட்டலை** (எந்த ஆவணங்கள்) மற்றும் **ஆபரேட்டர்களைப்** பயன்படுத்தும் **ஆவண புதுப்பிப்புக்கு** எடுத்துக்கொள்கின்றன, `$set` (ஒரு புலத்தை அமைக்க), `$inc` (அதிகரிக்க), `$push` (ஒரு வரிசையில் சேர்க்க) போன்றவை — நீங்கள் முழு ஆவணத்தை மாற்றவில்லை (நோக்கம் இல்லாவிட்டால்).

## Delete — ஆவணங்களை அகற்றவும்

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

## இது ஏன் முக்கியம்

CRUD செயல்பாடுகள் எந்தவொரு தரவுத்தளத்துடனும் பணிபுரிவதன் ভিত்தியாகும், எனவே MongoDB இல் அவை எவ்வாறு செயல்படுகின்றன என்பதைப் புரிந்துகொள்வது அத்தியாவசிய நாளாந்த அறிவாகும்.

செயல்பாடுகள் — **ஆவணங்களைச் சேர்த்தல்** (`insertOne`/`insertMany`), **வடிகட்டல் ஆவணங்கள் மற்றும் ஆபரேட்டர்களைக் கொண்டு கேள்வி செய்தல்** (`find`/`findOne` with `{ field: value }` வடிகட்டல், `$gt` போன்ற ஒப்பிடல் ஆபரேட்டர்கள், மற்றும் புலங்களைத் தேர்ந்தெடுக்க முன்வைப்புகள்), **வடிகட்டல் மற்றும் আপডேட் ஆபரேட்டர்களுடன் புதுப்பிக்கல்** (`updateOne`/`updateMany` with `$set`, `$inc`, முதலியன), மற்றும் **நீக்குதல்** (`deleteOne`/`deleteMany`) — MongoDB இல் தரவை உருவாக்குவது, படிப்பது, திருத்துவது மற்றும் அகற்றுவது எப்படி என்பது, இது பெரும்பாலான தரவுத்தள தொடர்பின் மূலம்.

MongoDB இன் தனிமையான அணுகுமுறையைப் புரிந்துகொள்வது முக்கியம்: கேள்விகள் **வடிகட்டல் ஆவணத்தைப்** பயன்படுத்துகின்றன (பொருந்த வேண்டியது, ஆபரேட்டர்களுடன் விவரிக்கும் JSON ஆன்மாவான பொருள்) rather than SQL's `WHERE` தொடரியல், மற்றும் আপডேட்டுகள் **ஆபடேட் ஆபரேட்டர்களைப்** பயன்படுத்துகின்றன (`$set` to change fields, `$inc` to increment, `$push` for arrays) முழு-ஆவண மாற்றம் செய்வதற்கு பதிலாக — ஒரு வேறுபட்ட ஆனால் கற்கக்கூடிய மாதிரி।

CRUD என்பது எந்த தரவு-இயக்கிய பயன்பாட்டிலும் அடிப்படை, நிலையான செயல்பாடு, மற்றும் MongoDB இன் CRUD முறைகள், வடிகட்டல்/ஆபரேட்டர் கேள்வி தொடரியல் மற்றும் ஆபடேட் ஆபரேட்டர்கள் எப்படி நீங்கள் தரவுத்தளத்துடன் நாளாந்த ஆ‍டி செய்கிறீர்கள் என்பதாக இருப்பதால், MongoDB CRUD செயல்பாடுகளைப் புரிந்துகொள்வது — முறைகள், வடிகட்டல்/ஆபரேட்டர் கேள்வி தொடரியல் மற்றும் ஆபடேட் ஆபரேட்டர்கள் — அவசியமான, அறிய வேண்டிய அறிவு, SQL க்கு SELECT/INSERT/UPDATE/DELETE ஐ அறிந்திருப்பதன் சமம் மற்றும் தரவுத்தளத்துடன் பணிபுரிவதற்கான நடைமுறை ভিত்தி.