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`, વગેરે) શરતો માટે. 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
```

আপডેટ્સ **ફિલ્ટર** (કયા ડોક્યુમેન્ટ્સ) અને **અપડેટ ડોક્યુમેન્ટ** લે છે જે **ઑપરેટર્સ** જેવા `$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` સાથે `{ field: value }` ફિલ્ટર્સ, `$gt` જેવા તુલનાત્મક ઑપરેટર્સ, અને ફીલ્ડ્સ પસંદ કરવા માટે projections), **અપડેટ કરવું** ફિલ્ટર્સ અને અપડેટ ઑપરેટર્સ સાથે (`updateOne`/`updateMany` સાથે `$set`, `$inc`, વગેરે), અને **કાઢી નાખવું** (`deleteOne`/`deleteMany`) — આ કિસ્સામાં MongoDB માં ડેટા બનાવવું, વાંચવું, સંશોધન કરવું, અને દૂર કરવું, જે મોટાભાગના ડેટાબેસ ઇન્ટરેક્શનનું મૂળ છે.

MongoDB ના વિશિષ્ટ અભિગમને સમજવું મહત્વનું છે: ક્વેરીઓ **ફિલ્ટર ડોક્યુમેન્ટ** (JSON જેવો ઑબ્જેક્ટ જે કેવી રીતે મેચ કરવું તે વર્ણવે છે, ઑપરેટર્સ સાથે) નો ઉપયોગ કરે છે SQL ના `WHERE` સિન્ટેક્સને બદલે, અને અપડેટ્સ **અપડેટ ઑપરેટર્સ** (`$set` ફીલ્ડ્સ બદલવા માટે, `$inc` વધારવા માટે, `$push` એરે્સ માટે) નો ઉપયોગ કરે છે સંપૂર્ણ-ડોક્યુમેન્ટ બદલવણીને બદલે — અલગ પણ શીખવા યોગ્ય મોડેલ.

CRUD એ કોઈપણ ડેટા-સંચાલિત એપ્લિકેશનમાં મૌલિક, સતત ઑપરેશન છે, અને MongoDB ના CRUD મેથડ્સ, ફિલ્ટર-ડોક્યુમેન્ટ ક્વેરીઓ, અને અપડેટ ઑપરેટર્સ તમે ડેટાબેસ સાથે દિવસ-દર-દિવસ ઇન્ટરેક્ટ કરો છો તેનો, MongoDB CRUD ઑપરેશનો સમજવું — મેથડ્સ, ફિલ્ટર/ઑપરેટર ક્વેરી સિન્ટેક્સ, અને અપડેટ ઑપરેટર્સ — આવશ્યક, અનિવાર્ય જ્ઞાન કોઈપણ MongoDB ડેવલપમેન્ટ માટે, SQL માટે SELECT/INSERT/UPDATE/DELETE જાણવાની સમતુલ્ય અને ડેટાબેસ સાથે કામ કરવાનો વ્યવહારિક આધાર।