MongoDB లో CRUD ఆపరేషన్లు ఎలా పని చేస్తాయి?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) ఆపరేషన్లు MongoDB లో కలెక్షన్‌ల మీద పద్ధతులను ఉపయోగిస్తాయి. అవి డాక్యుమెంట్‌లతో పని చేస్తాయి మరియు సరళమైన, JSON-లాంటి క్వేరీ సింటాక్స్‌ను ఉపయోగిస్తాయి — SQL నుండి భిన్నంగా కానీ సంభావితంగా సమానమైనవి.

## డాక్యుమెంట్‌లను సృష్టించండి — insert

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

## డాక్యుమెంట్‌లను చదవండి — query

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

క్వేరీలు **filter document** (`{ field: value }`) ఉపయోగిస్తాయి ఇది సరిపోలిస్తున్నవాటిని వివరిస్తుంది, ఆపరేటర్‌లతో (`$gt`, `$lt`, `$in`, మొదలైనవి) షరతుల కోసం. Projection (`{ 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
```

আপডేట్‌లు **filter** (ఏ డాక్యుమెంట్‌లు) తీసుకుంటాయి మరియు **update document** **ఆపరేటర్‌ల** ఉపయోగంతో (`$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`), **filter documents మరియు ఆపరేటర్‌లతో క్వేరీ చేయడం** (`find`/`findOne` with `{ field: value }` filters, `$gt` వంటి పోలిక ఆపరేటర్‌లు, మరియు ఫీల్డ్‌లను ఎంచుకోవటానికి projections), **filter మరియు update ఆపరేటర్‌లతో నవీకరించడం** (`updateOne`/`updateMany` with `$set`, `$inc`, మొదలైనవి), మరియు **తొలగించడం** (`deleteOne`/`deleteMany`) — MongoDB లో డేటాను సృష్టించడం, చదవడం, సవరించడం, మరియు తీసివేయడం ఎలా చేస్తుందో, ఇది చాలా డేటాబేస్ ఇంటరঅ్యాక్షన్‌ల కోర్.

MongoDB యొక్క విభిన్న విధానాన్ని అర్థం చేసుకోవడం ముఖ్యమైనది: క్వేరీలు **filter document** (JSON-లాంటి ఆబ్జెక్ట్ సరిపోలిస్తున్నవాటిని వివరిస్తూ, ఆపరేటర్‌లతో) ఉపయోగిస్తాయి SQL యొక్క `WHERE` సింటాక్స్‌కు బదులుగా, మరియు అపడేట్‌లు **update ఆపరేటర్‌లను** ఉపయోగిస్తాయి (`$set` ఫీల్డ్‌లను మార్చటానికి, `$inc` ఇంక్రిమెంట్ చేయటానికి, `$push` arrays కోసం) పూర్తి-డాక్యుమెంట్ భర్తీకు బదులుగా — ఎక్కువ కానీ నేర్చుకోదగిన మోడల్.

CRUD అనేది ఏదైనా డేటా-ఆధారిత ఆ్యాప్లికేషన్‌లో ప్రాథమిక, స్థిరమైన ఆపరేషన్ కనుక, మరియు MongoDB CRUD పద్ధతులు, filter-document క్వేరీలు, మరియు update ఆపరేటర్‌లు డేటాబేస్‌తో రోజువారీ ఇంటరঅ్యాక్ట్ చేయటకు ఎలా ఉపయోగించారో కనుక, MongoDB CRUD ఆపరేషన్‌లను అర్థం చేసుకోవడం — పద్ధతులు, filter/ఆపరేటర్ క్వేరీ సింటాక్స్, మరియు update ఆపరేటర్‌లు — ఏదైనా MongoDB డెవలपમెంట్ కోసం ముఖ్యమైనది, తప్పనిసరిగా-తెలుసుకోవాల్సిన జ్ఞానం, SQL కోసం SELECT/INSERT/UPDATE/DELETE తెలుసుకోవటానికి సమానమైనది మరియు డేటాబేస్‌తో పని చేయటకు ఆచరణాత్మక ఆధారం.