તમે દસ્તાવેજો કેવી રીતે શામેલ કરો, અપડેટ કરો અને ડીલીટ કરો?

Question

Accepted Answer

MongoDB ડેટાને **insert** (`insertOne`/`insertMany`), **update** (`updateOne`/`updateMany` operators સાથે), અને **delete** (`deleteOne`/`deleteMany`) methods વડે સંશોધિત કરે છે. અપડેટ્સ સંપૂર્ણ દસ્તાવેજો બદલવાને બદલે **અપડેટ 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 સાથે અપડેટ કરો (સમગ્ર ડોક બદલશો નહીં)

```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 operations એ છે કે કેવી રીતે એપ્લિકેશનો MongoDB માં **ડેટા સંશોધિત કરે છે**, કોઈપણ ડેટા-સંચાલિત એપ્લિકેશનમાં મૌલિક છે, તેથી તેમને સમજવું આવશ્યક રોજનું જ્ઞાન છે.

Methods જાણવું (`insertOne`/`insertMany` બનાવવા માટે, `updateOne`/`updateMany` સંશોધન માટે, `deleteOne`/`deleteMany` દૂર કરવા માટે) મૂળ બાબતો આવરી લે છે.

**સૌથી મહત્વપૂર્ણ અને સામાન્ય રીતે ખોટી રીતે સમજાતી બાબત** એ છે કે MongoDB અપડેટ્સ **અપડેટ operators** (`$set`, `$inc`, `$push`, `$pull`, વગેરે) વાપરે છે *ચોક્કસ* ફીલ્ડોને સંશોધિત કરવા માટે — અને નિર્ણાયક રીતે, **operator ભૂલવાથી સંપૂર્ણ દસ્તાવેજ બદલાય છે** (એક કુખ્યાત ભૂલ જ્યાં `updateOne({...}, {age: 31})` બીજા બધા ફીલ્ડોને દૂર કરે છે, ફક્ત `age` બાકી રહે છે), તેથી હંમેશા `$set` (અને અન્ય operators) ફીલ્ડ-સ્તરીય અપડેટ્સ માટે વાપરવાનું સમજવું સુધારણાના માટે આવશ્યક છે.

સામાન્ય operators જાણવું (`$set`, `$inc`카ウન્ટર માટે, `$push`/`$pull`/`$addToSet` arrays માટે — array operators ખાસ કરીને સુસંગત હોવાને કારણે MongoDB ના array-સમૃદ્ધ દસ્તાવેજોને) આવશ્યક રોજનું જ્ઞાન છે.

**Upsert** (`{ upsert: true }` — જો કોઈ મેચ વર્તમાન નથી તો insert કરો, MongoDB ની insert-or-update) સમજવું સામાન્ય insert-or-update પેટર્ન માટે મૂલ્યવાન છે.

પણ તે નોટ કરવું યોગ્ય છે કે `deleteMany({})` નું જોખમ (બધું ડીલીટ કરવું — SQL માં missing-WHERE જોખમ જેવું).

ડેટા સંશોધિત કરવું મૌલિક હોવાથી, અને MongoDB ના operator-આધારિત અપડેટ્સ (document-replacement ભૂલ સાથે), array operators, અને upsert એ છે કે કેવી રીતે તમે ડેટા યોગ્ય રીતે બદલો, તેથી insert/update/delete સમજવું — ખાસ કરીને નિર્ણાયક update-operator તફાવત (આકસ્મિક document replacement ટાળવું) — આવશ્યક, MongoDB વિકાસમાં કોઈપણ વ્યક્તિ માટે જ્ઞાત હોવું જોઈએ, જ્યાં operator ભૂલ ખાસ કરીને વાસ્તવિક બગ્સનો વારંવાર સ્રોત છે.