તમે MongoDB માં સંબંધો કેવી રીતે મોડેલ કરો છો?

Question

Accepted Answer

MongoDB સંબંધોને (એક-થી-એક, એક-થી-ઘણા, ઘણા-થી-ઘણા) **embedding** અથવા **referencing** દ્વારા મોડેલ કરે છે — પસંદગી સંબંધના cardinality, ડેટા કેવી રીતે ઍક્સેસ કરવામાં આવે છે, અને તે શેર કરવામાં આવે છે કે કેમ તેના પર આધાર રાખે છે। SQL ના યુનિફોર્મ foreign-key અભિગમથી વિપરીત, MongoDB પ્રત્યેક સંબંધ માટે લવચીકતા પ્રદાન કરે છે।

## એક-થી-એક

```js
// usually EMBED (the related data belongs to the document)
{ _id: ObjectId("..."), name: "Ann", profile: { bio: "...", avatar: "..." } }
// → one query gets both; they're accessed together
```

## એક-થી-ઘણા (સૌથી સામાન્ય — અને સૌથી સૂક્ષ્મ)

```js
// ONE-TO-FEW → embed (bounded, accessed together)
{ _id: ObjectId("..."), name: "Ann", addresses: [ {...}, {...} ] }  // a few addresses

// ONE-TO-MANY → reference (the "many" side references the "one")
// authors collection: { _id: "a1", name: "Ann" }
// books collection:   { _id: "b1", authorId: "a1", title: "..." }  // each book references its author

// ONE-TO-SQUILLIONS (huge/unbounded) → ALWAYS reference (never embed unbounded data)
// e.g. a user with millions of log entries → separate collection, reference by userId
```

મુખ્ય સૂક્ષ્મતા: **એક-થી-કેટલાક** (embed), **એક-થી-ઘણા** (ઘણા બાજુ થી reference), **એક-થી-squillions** (હંમેશા reference — કદી unbounded ડેટા embed કરશો નહીં, 16MB document limit અને કર્મક્ષમતા માટે).

## ઘણા-થી-ઘણા

```js
// reference with an array of ids (on one or both sides)
{ _id: "s1", name: "Student", courseIds: ["c1", "c2"] }     // student → courses
{ _id: "c1", name: "Course", studentIds: ["s1", "s2"] }     // course → students (optional)
// → query and $lookup to resolve; or a separate "enrollments" collection (junction-like)
```

ઘણા-થી-ઘણા referenced ids ના arrays (એક અથવા બંને બાજુ પર) ઉપયોગ કરે છે, અથવા સમૃદ્ધ સંબંધ ડેટા માટે એક અલગ junction-જેવા collection માટે.

## References ને resolve કરવું ($lookup)

```js
// join referenced data when needed
db.books.aggregate([
  { $lookup: { from: "authors", localField: "authorId", foreignField: "_id", as: "author" } }
]);
```

## શા માટે તે મહત્વનું છે

સંબંધોને મોડેલ કરવું ડેટાબેસ ડિઝાઇનનું મૂળભૂત છે, અને MongoDB ની લવચીક, ઍક્સેસ-પેટર્ન-ચાલિત અભિગમ SQL ના યુનિફોર્મ foreign keys થી અલગ છે, તેથી MongoDB માં સંબંધોને મોડેલ કરવું કેવી રીતે કરવું તે સમજવું અસરકારક schemas ડિઝાઇન કરવા માટે આવશ્યક છે।

મુખ્ય insight એ છે કે MongoDB સંબંધોને **embedding અથવા referencing** દ્વારા મોડેલ કરે છે સંબંધના લક્ષણો પર આધાર રાખીને — અને **કેવી રીતે cardinality પસંદગીને અસર કરે છે** તે સમજવું મહત્વનું કૌશલ્ય છે: **એક-થી-એક** (સામાન્યત: embed — એક સાથે ઍક્સેસ કરવામાં આવે છે), **એક-થી-ઘણા** તેની મહત્વપૂર્ણ nuances સાથે (**એક-થી-કેટલાક** → bounded together-accessed ડેટા માટે embed કરો; **એક-થી-ઘણા** → ઘણા બાજુ થી reference કરો; **એક-થી-squillions** → હંમેશા reference કરો, 16MB document limit અને કર્મક્ષમતા માટે unbounded ડેટા embed ન કરો), અને **ઘણા-થી-ઘણા** (referenced ids ના arrays, અથવા एक junction-જેવું collection).

યો cardinality-driven decision-making (ખાસ કરીને જ્યારે ડેટા embed કરવા માટે ખૂબ મોટો/unbounded છે તે સમજવું) સામાન્ય ભૂલો ટાળવા માટે આવશ્યક છે જેમ કે unbounded arrays embedding (documents ને bloating કરતું, limits hit કરતું) અથવા over-referencing ડેટા જે embed કરવું જોઈએ.

**References ને resolve કરવું** કેવી રીતે સમજવું `$lookup` સાથે જ્યારે joins જરૂરી છે તે ચિત્રને સમાપ્ત કરે છે.

અસ્તિત્વમાં, entities વચ્ચે સંબંધો મોટાભાગના ડેટા models માં અંતર્ભૂત છે, અને કારણ કે MongoDB ની લવચીક per-relationship અભિગમ (cardinality અને ઍક્સેસ patterns પર આધાર રાખીને embed વિ reference) SQL ના યુનિફોર્મ foreign keys કરતા મૌલિક રીતે અલગ અને વધુ nuanced છે, MongoDB માં સંબંધોને મોડેલ કરવું કેવી રીતે કરવું તે સમજવું — cardinality-based embed/reference decisions (ખાસ કરીને one-to-few/many/squillions distinction) અને references ને resolve કરવું — અસરકારક MongoDB schema design માટે આવશ્યક, વારંવાર-લાગુ નાણું છે, embed/reference મૂળતત્વો પર બનેલું હોય તે સંબંધો સંભાળવા માટે દરેક વાસ્તવિક એપ્લિકેશન ધરાવે છે, અને સાઉન્ડ MongoDB modeling અને naïve relational ports વચ્ચે તફાવત કરતા મુખ્ય ક્ષેત્ર છે।