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 பக்கத்திலிருந்து reference), **one-to-squillions** (எப்போதும் reference — 16MB document வரம்பு மற்றும் செயல்திறன் காரணமாக எப்போதும் সীमাহீன தரவை 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 (ஒரு அல்லது இரு பக்கங்களில்) அல்லது rich relationship data இற்கான தனிப்பட்ட junction-போன்ற collection ஐ பயன்படுத்துகிறது.

## References தீர்க்கல் ($lookup)

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

## இது ஏன் முக்கியமாக இருக்கிறது

உறவுகளை மாதிரியாக்குவது database design க்கு அடிப்படையாகும், மேலும் MongoDB இன் நমனீய, access-pattern-guided அணுகுமுறை SQL இன் சீரான foreign keys ஐ விட வேறுபட்டுள்ளது, எனவே MongoDB இல் உறவுகளை மாதிரியாக்குவதை புரிந்துகொள்வது திறமையான schemas ஐ வடிவமைப்பதற்கு அத்യாவசியமாகும்.

மূல insight என்னவென்றால் MongoDB உறவுகளை **embedding அல்லது referencing** மூலம் மாதிரியாக்குகிறது உறவின் பண்புகளின் அடிப்படையில் — மற்றும் **எவ்வாறு cardinality இதன் தேர்வைப் பாதிக்கிறது** என்பதை புரிந்துகொள்வது முக்கிய திறமை: **one-to-one** (வழக்கமாக embed — ஒன்றாக அணுகப்படுகிறது), **one-to-many** அதன் முக்கிய நுணுக்கங்களுடன் (**one-to-few** → bounded together-accessed data க்கு embed; **one-to-many** → many பக்கத்திலிருந்து reference; **one-to-squillions** → எப்போதும் reference, 16MB document வரம்பு மற்றும் செயல்திறன் காரணமாக சீமாहीன தரவை embed செய்ய வேண்டாம்), மற்றும் **many-to-many** (referenced ids இன் arrays, அல்லது junction-போன்ற collection).

இந்த cardinality-guided decision-making (குறிப்பாக எப்போது தரவு embed செய்ய மிக பெரியது/சீமாहीனமாக இருக்கிறது என்பதை அங்கீகரிப்பது) documents bloat செய்கல், limits அடைய போன்ற பொதுவான பிழைகளைத் தவிர்ப்பதற்கு அத்யாவசியமாகும்.

**References தீர்க்கல்** `$lookup` உடன் joins தேவைப்படும்போது புரிந்துகொள்வது படத்தை நிறைவு செய்கிறது.

ఎంटिटીகளுக்கு இடையிலான உறவுகள் பெரும்பாலான தரவு models இல் உள்ளார்ந்தவை, மற்றும் MongoDB இன் நமनीய per-relationship அணுகுமுறை (cardinality மற்றும் access patterns ஆதாரமாக embed vs reference) SQL இன் சீரான foreign keys ஐ விட அடிப்படையில் வேறுபட்டுள்ளது மற்றும் மிக நுணுக்கமாக இருக்கிறது, MongoDB இல் உறவுகளை மாதிரியாக்குவதை புரிந்துகொள்வது — cardinality-based embed/reference முடிவுகள் (குறிப்பாக one-to-few/many/squillions வேறுபாட்டை) மற்றும் references தீர்க்கல் — திறமையான MongoDB schema design க்கு அத்யாவசியமான, அடிக்கடி-பயன்படுத்தப்படும் அறிவு, embed/reference fundamentals ஐ அடிப்படையாக வைத்து ஒவ்வொரு உண்மையான application மிக நுணுக்கமாக இருக்கிறது, மற்றும் sound MongoDB modeling ஐ naive relational ports இலிருந்து வேறுபடுத்தும் ஒரு முக்கிய பகுதி.