MongoDB లో సంబంధాలను ఎలా మోడల్ చేస్తారు?

Question

Accepted Answer

MongoDB సంబంధాలను (one-to-one, one-to-many, many-to-many) **embedding** లేదా **referencing** ద్వారా మోడల్ చేస్తుంది — ఎంపిక సంబంధం యొక్క cardinality, డేటా ఎలా ఆక్సెస్ చేయబడుతుందో, మరియు అది భాగస్వామ్యం చేయబడిందా అనే దానిపై ఆధారపడుతుంది. SQL యొక్క ఏకరూప foreign-key విధానానికి భిన్నంగా, MongoDB ప్రతి సంబంధానికి సరళత అందించે.

## One-to-one

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

## One-to-many (అత్యంత సాధారణ — మరియు అత్యంత సూక్ష్మమైన)

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

ప్రధాన సూక్ష్మత: **one-to-few** (embed), **one-to-many** (many side నుండి reference), **one-to-squillions** (ఎల్లప్పుడు reference — 16MB డాక్యుమెంట్ లిమిట్ మరియు పనితీరు కారణంగా బౌండ్‌లేని డేటాను ఎందుకూ embed చేయవద్దు).

## Many-to-many

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

Many-to-many referenced ids (ఒక వైపు లేదా రెండు వైపులా) యొక్క arrays ను ఉపయోగిస్తుంది, లేదా గొప్ప సంబంధ డేటా కోసం ఒక వేరు junction-like collection ను ఉపయోగిస్తుంది.

## References ($lookup) ను Resolve చేయడం

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

## ఇది ఎందుకు ముఖ్యమైనది

សంబంధాలను మోడల్ చేయడం డేటాబేస్ డిజైన్‌కు ప్రాథమికమైనది, మరియు MongoDB యొక్క నమ్యమైన, access-pattern-driven విధానం SQL యొక్క ఏకరూప foreign keys నుండి భిన్నంగా ఉంటుంది, కాబట్టి MongoDB లో సంబంధాలను మోడల్ చేయడం ఎలాగో అర్థం చేసుకోవడం సమర్థవంతమైన schemas నిర్మాణం కోసం అవసరం.

ప్రధాన insight ఏమిటంటే MongoDB సంబంధాలను **embedding లేదా referencing** ద్వారా సంబంధం యొక్క లక్షణాల ఆధారంగా మోడల్ చేస్తుంది — మరియు **cardinality ఎంపికను ఎలా ప్రభావితం చేస్తుందో అర్థం చేసుకోవడం** నిర్ణయాత్మక నైపుణ్యం: **one-to-one** (సాధారణంగా embed — కలిసి ఆక్సెస్ చేయబడుతుంది), **one-to-many** దీని ముఖ్యమైన సూక్ష్మతలతో (**one-to-few** → bounded together-accessed డేటా కోసం embed; **one-to-many** → many side నుండి reference; **one-to-squillions** → ఎల్లప్పుడు reference, 16MB డాక్యుమెంట్ లిమిట్ మరియు పనితీరు కారణంగా బౌండ్‌లేని డేటాను embedding చేయవద్దు), మరియు **many-to-many** (referenced ids యొక్క arrays, లేదా junction-like collection).

ఈ cardinality-driven సిద్ధాంతం (ముఖ్యంగా డేటా embed చేయడానికి చాలా పెద్దదైనప్పుడు/బౌండ్‌లేనిప్పుడు గుర్తించడం) సాధారణ తప్పుల నుండి తప్పించడానికి అవసరం జैసे unbounded arrays embedding (documents bloating, limits hitting) లేదా embedding చేయాల్సిన డేటాను over-referencing చేయడం.

joins అవసరమైనప్పుడు `$lookup` తో **references ను resolve చేయడం** ఎలాగో అర్థం చేసుకోవడం చిత్రాన్ని పూర్తి చేస్తుంది.

చాలా డేటా మోడల్‌లలో entities మధ్య సంబంధాలు అంతర్గతమైనవి కాబట్టి, మరియు MongoDB యొక్క నమ్యమైన per-relationship విధానం (cardinality మరియు access patterns ఆధారంగా embed vs reference) SQL యొక్క ఏకరూప foreign keys కంటే ప్రాథమికంగా భిన్నమైనది మరియు మరింత సూక్ష్మమైనది కాబట్టి, MongoDB లో సంబంధాలను మోడల్ చేయడం ఎలాగో అర్థం చేసుకోవడం — cardinality-based embed/reference నిర్ణయాలు (ముఖ్యంగా one-to-few/many/squillions వ్యత్యాసం) మరియు references ను resolve చేయడం — సమర్థవంతమైన MongoDB schema డిజైన్‌కు అవసరమైన, తరచుగా-అన్వయించిన జ్ఞానం, embed/reference ఆధారం మీద నిర్మాణం చేసి ప్రతి నిజ అనువర్తనం కలిగి ఉన్న సంబంధాలను నిర్వహించడం, మరియు నిశ్చల MongoDB మోడలింగ్‌ను నిరపేక్ష relational porting నుండి వేరుచేసే ప్రధాన ప్రాంతం.