ਤੁਸੀਂ MongoDB ਵਿੱਚ ਸਬੰਧਾਂ ਦਾ ਮਾਡਲ ਕਿਵੇਂ ਬਣਾਉ ਦੇ ਹੋ?

Question

Accepted Answer

MongoDB **embedding** ਜਾਂ **referencing** ਦੇ ਮਾਧਿਅਮ ਨਾਲ ਸਬੰਧਾਂ (one-to-one, one-to-many, many-to-many) ਦਾ ਮਾਡਲ ਬਣਾਉਂਦਾ ਹੈ — ਚੋਣ ਸਬੰਧ ਦੀ cardinality, ਡਾਟਾ ਕਿਵੇਂ access ਹੁੰਦਾ ਹੈ, ਅਤੇ ਕੀ ਇਹ ਸ਼ੇਅਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਇਸ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ। 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 ਪਾਸੇ ਤੋਂ reference), **one-to-squillions** (ਹਮੇਸ਼ਾ reference — ਕਦੇ unbounded data embed ਨਾ ਕਰੋ, 16MB ਦਾ document limit ਅਤੇ 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 (ਇੱਕ ਜਾਂ ਦੋਵਾਂ ਪਾਸਿਆਂ ਉੱਤੇ) ਜਾਂ rich relationship ਡਾਟਾ ਲਈ ਇੱਕ ਨਵੀਂ junction-ਜਿਹੀ collection ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

## References ਨੂੰ ਹੱਲ ਕਰਨਾ ($lookup)

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

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰਖਦਾ ਹੈ

Schemae ਦਾ ਮਾਡਲ ਬਣਾਉਣਾ ਡਾਟਾਬੇਸ ਡਿਜ਼ਾਈਨ ਲਈ ਬੁਨਿਆਦੀ ਹੈ, ਅਤੇ MongoDB ਦੀ ਲਚਕਦਾਰ, access-pattern-driven ਪਹੁੰਚ SQL ਦੀ ਯੂਨੀਫਾਰਮ foreign keys ਤੋਂ ਵੱਖਰੀ ਹੈ, ਇਸ ਲਈ MongoDB ਵਿੱਚ relationships ਨੂੰ ਮਾਡਲ ਕਰਨਾ ਸਿੱਖਣਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ schemas ਦੇ ਡਿਜ਼ਾਈਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਮੁੱਖ ਸੂਝ ਇਹ ਹੈ ਕਿ MongoDB relationships ਨੂੰ **embedding ਜਾਂ referencing** ਦੇ ਮਾਧਿਅਮ ਨਾਲ cardinality ਦੇ ਆਧਾਰ ਉੱਤੇ ਮਾਡਲ ਕਰਦਾ ਹੈ — ਅਤੇ ਸਮਝਣਾ **ਕਿ cardinality ਕਿਵੇਂ ਚੋਣ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਦੀ ਹੈ** ਮੁੱਖ ਹੁਨਰ ਹੈ: **one-to-one** (ਆਮ ਤੌਰ ਉੱਤੇ embed — ਇਕੱਠੇ access ਕੀਤਾ), **one-to-many** ਅਪਣੀਆਂ ਮਹੱਤਵਪੂਰਨ nuances ਨਾਲ (**one-to-few** → embed bounded together-accessed ਡਾਟਾ ਲਈ; **one-to-many** → many ਪਾਸਿਅਤ reference; **one-to-squillions** → ਹਮੇਸ਼ਾ reference, 16MB document limit ਅਤੇ performance ਕਾਰਨ ਕਦੇ unbounded ਡਾਟਾ embed ਨਾ ਕਰੋ), ਅਤੇ **many-to-many** (referenced ids ਦੀ arrays, ਜਾਂ ਇੱਕ junction-ਜਿਹੀ collection)।

ਇਹ cardinality-driven decision-making (ਖਾਸ ਕਰਕੇ ਸਮਝਣਾ ਕਿ ਕਦੋਂ ਡਾਟਾ ਬਹੁਤ ਵੱਡਾ/unbounded ਹੈ embed ਕਰਨ ਲਈ) common ਗਲਤੀਆਂ ਨੂੰ ਰੋਕਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਜਿਵੇਂ unbounded arrays ਨੂੰ embed ਕਰਨਾ (ਡਾਕੂਮੈਂਟਸ ਨੂੰ bloat ਕਰਨਾ, limits ਨੂੰ ਹਿਤ ਕਰਨਾ) ਜਾਂ over-referencing ਡਾਟਾ ਜੋ embed ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

`$lookup` ਨਾਲ **references ਨੂੰ ਹੱਲ ਕਰਨਾ** ਸਮਝਣਾ ਜਦੋਂ joins ਦੀ ਲੋੜ ਹੋਵੇ ਤਸਵੀਰ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ।

ਕਿਉਂਕਿ entities ਦੇ ਵਿਚਕਾਰ relationships ਬਹੁਤੇ data models ਵਿੱਚ ਮੌਜੂਦ ਹਨ, ਅਤੇ ਕਿਉਂਕਿ MongoDB ਦੀ ਲਚਕਦਾਰ per-relationship ਪਹੁੰਚ (cardinality ਅਤੇ access patterns ਦੇ ਆਧਾਰ ਉੱਤੇ embed vs reference) ਬੁਨਿਆਦੀ ਤੌਰ ਉੱਤੇ SQL ਦੀ ਯੂਨੀਫਾਰਮ foreign keys ਨਾਲੋਂ ਵੱਧ nuanced ਹੈ, MongoDB ਵਿੱਚ relationships ਨੂੰ ਮਾਡਲ ਕਰਨਾ ਸਮਝਣਾ — cardinality-based embed/reference decisions (ਖਾਸ ਕਰਕੇ one-to-few/many/squillions ਵਿਭਾਗ) ਅਤੇ references ਨੂੰ ਹੱਲ ਕਰਨਾ — MongoDB schema design ਲਈ ਪ੍ਰਭਾਵਸ਼ਾਲੀ, ਅਕਸਰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਗਿਆਨ ਹੈ, embed/reference ਬਨਿਆਦ ਉੱਤੇ ਬਿਲਡ ਕਰਨਾ ਪ੍ਰਬਰ relationships ਦੇ ਲਈ ਜੋ ਹਰ ਅਸਲ ਐਪਲੀਕੇਸਨ ਕੋਲ ਹਨ, ਅਤੇ MongoDB modeling ਦੇ ਬਾਰੇ ਸਮਝਦਾਰੀ ਅਤੇ naive relational ports ਦੇ ਵਿਚਕਾਰ ਫਰਕ ਕਰਨ ਵਾਲਾ ਇੱਕ ਮੁੱਖ ਖੇਤਰ ਹੈ।