आप MongoDB में relationships को कैसे model करते हैं?

Question

Accepted Answer

MongoDB relationships (one-to-one, one-to-many, many-to-many) को **embedding** या **referencing** के माध्यम से model करता है — चुनाव relationship की cardinality, data कैसे access किया जाता है, और क्या यह साझा है, पर निर्भर करता है। SQL के समान foreign-key दृष्टिकोण के विपरीत, MongoDB प्रति relationship लचीलापन प्रदान करता है।

## 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 — कभी भी unbounded data को embed न करें, 16MB document सीमा और performance के कारण)।

## 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 (एक या दोनों तरफ) का उपयोग करता है, या समृद्ध relationship data के लिए एक अलग junction-जैसा collection।

## References को resolve करना ($lookup)

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

## यह क्यों महत्वपूर्ण है

Relationships को model करना database design के लिए मौलिक है, और MongoDB का लचीला, access-pattern-संचालित दृष्टिकोण SQL के समान foreign keys से भिन्न है, इसलिए MongoDB में relationships को model करना समझना प्रभावी schemas डिजाइन करने के लिए आवश्यक है।

मुख्य अंतर्दृष्टि यह है कि MongoDB relationship की विशेषताओं के आधार पर **embedding या referencing** के माध्यम से relationships को model करता है — और **cardinality चुनाव को कैसे प्रभावित करती है** यह समझना महत्वपूर्ण कौशल है: **one-to-one** (आमतौर पर embed — एक साथ access किया जाता है), **one-to-many** अपनी महत्वपूर्ण सूक्ष्मताओं के साथ (**one-to-few** → bounded एक साथ access किए गए data के लिए embed; **one-to-many** → many side से reference; **one-to-squillions** → हमेशा reference, 16MB document सीमा और performance के कारण unbounded data को कभी embed न करना), और **many-to-many** (referenced ids के arrays, या एक junction-जैसा collection)।

यह cardinality-संचालित निर्णय-निर्माण (विशेष रूप से यह पहचानना कि data कब embed करने के लिए बहुत बड़ा/unbounded है) unbounded arrays को embed करने (documents को फुलाना, सीमाओं तक पहुँचना) या ऐसे data को over-reference करने जैसी सामान्य गलतियों से बचने के लिए आवश्यक है जिसे embed किया जाना चाहिए।

जब joins की आवश्यकता हो तो `$lookup` के साथ **references को resolve करना** समझना तस्वीर को पूरा करता है।

चूँकि entities के बीच relationships अधिकांश data models में निहित हैं, और चूँकि MongoDB का लचीला प्रति-relationship दृष्टिकोण (cardinality और access patterns के आधार पर embed बनाम reference) SQL के समान foreign keys से मौलिक रूप से भिन्न और अधिक सूक्ष्म है, MongoDB में relationships को model करना समझना — cardinality-आधारित embed/reference निर्णय (विशेष रूप से one-to-few/many/squillions भेद) और references को resolve करना — प्रभावी MongoDB schema design के लिए आवश्यक, बार-बार लागू होने वाला ज्ञान है, जो हर वास्तविक application में मौजूद relationships को संभालने के लिए embed/reference मूल बातों पर आधारित है, और एक प्रमुख क्षेत्र जो सही MongoDB modeling को naive relational ports से अलग करता है।