MongoDB-ல் schemas எப்படி design செய்வீர்கள்?

Question

Accepted Answer

MongoDB schema design என்பது ஒரு முக்கிய முடிவை மையமாக வைத்துள்ளது: **embedding** (தொடர்புடைய தரவை ஒரு document-ன் உள்ளே சேமிப்பது) vs **referencing** (தொடர்புடைய தரவை தனி documents/collections-ல் சேமித்து references மூலம் இணைப்பது). SQL-ன் normalize-by-default போலன்றி, MongoDB design தரவு *எப்படி அணுகப்படுகிறது* என்பதற்கு optimized.

## Embedding — தொடர்புடைய தரவை ஒன்றாக சேமிக்கவும்

```js
// embed related data within the document
{
  _id: ObjectId("..."),
  name: "Ann",
  address: { city: "NY", zip: "10001" },        // embedded sub-document
  orders: [                                      // embedded array of orders
    { product: "Phone", amount: 999 },
    { product: "Case", amount: 20 }
  ]
}
// → ONE query gets the user AND their address AND orders (no joins)
```

**Embedding** என்பது தொடர்புடைய தரவை ஒரு document-ல் வைத்து — ஒரு single query-ல் அனைத்தையும் வாசிக்கவும் (வேகமாக, joins இல்லை). தரவு ஒன்றாக அணுகப்படும் மற்றும் "contains" relationships-க்கு நல்லது.

## Referencing — தனி documents-ஐ link செய்யவும்

```js
// store a reference (id) to a document in another collection
{ _id: ObjectId("u1"), name: "Ann" }                          // users collection
{ _id: ObjectId("o1"), userId: ObjectId("u1"), product: "Phone" } // orders collection
// → query orders by userId; use $lookup to join when needed
```

**Referencing** என்பது தரவை தனியாக சேமித்து id மூலம் link செய்வது (foreign key போல) — தனியாக query செய்யவும் அல்லது `$lookup` மூலம் join செய்யவும்.

## Embed vs reference எப்போது செய்வது

```text
EMBED when:
  ✓ data is accessed TOGETHER (read the parent → you want the children)
  ✓ a "contains"/ownership relationship (address, order line items)
  ✓ the embedded data is bounded (not unboundedly growing)
  ✓ one-to-few relationships

REFERENCE when:
  ✓ data is large or grows UNBOUNDEDLY (avoid huge documents — 16MB doc limit!)
  ✓ data is accessed/updated INDEPENDENTLY
  ✓ many-to-many or one-to-many with many
  ✓ the same data is shared/referenced by many documents (avoid duplication)
```

## Access patterns-க்கு design செய்யவும் (முக்கிய principle)

```text
MongoDB schema design is driven by HOW YOU QUERY the data, not pure normalization:
  → Structure data so common queries are efficient (often a single document read).
  → "Data that is accessed together should be stored together."
  → This may mean DENORMALIZING (some duplication) for read efficiency — acceptable
    in MongoDB, traded against update complexity.
```

## ஏன் இது முக்கியமாக உள்ளது

Schema design என்பது MongoDB-ல் மிக முக்கியமானது — இது SQL-ல் இருந்து வேறுபட்டது மற்றும் வாதிடலாம் அதிக விளைவை ஏற்படுத்துகிறது, ஏனெனில் MongoDB-ன் flexible document model உங்களுக்கு performance மற்றும் maintainability-ஐ குறிப்பிடத்தக்க அளவில் பாதிக்கும் தேர்வுகளை வழங்குகிறது, எனவே இதைப் புரிந்துகொள்வது effective MongoDB applications கட்டுவதற்கு அপরிहार்யமாக உள்ளது.

முக்கிய முடிவு — **embedding vs referencing** — என்பது MongoDB design-ன் வரையறை செய்யும் தேர்வாக உள்ளது: **embedding** (ஒரு document-ல் தொடர்புடைய தரவை சேமிப்பது) தொடர்புடைய தரவின் வேகமான single-query reads-ஐ (joins இல்லை) செயல்படுத்துகிறது மற்றும் தரவு ஒன்றாக அணுகப்படும் மற்றும் "contains" relationships-க்கு பொருத்தமாக உள்ளது, அதேசமயம் **referencing** (தனி documents-ஐ id-ல் link செய்வது) பெரிய/unbounded தரவு, சுயாதீனமாக-அணுகப்படும் தரவு, மற்றும் shared/many relationships-க்கு பொருத்தமாக உள்ளது.

**ஒவ்வொன்றை எப்போது பயன்படுத்துவது** புரிந்துகொள்வது (bounded, together-accessed, owned தரவுக்கு embed செய்யவும்; பெரிய/growing, independent, shared, அல்லது many relationships-க்கு reference செய்யவும் — மற்றும் MongoDB-ன் 16MB document size limit-ஐ கவனத்தில் கொள்ளவும்) என்பது முக்கிய দক்ஷதை.

மிக முக்கியமாக, வழிகாட்டும் principle-ஐ புரிந்துகொள்வது — **access patterns-க்கு design செய்யவும்** (தரவை *நீங்கள் அதை எப்படி query செய்கிறீர்கள்* என்பதைச் சுற்றிலும் গட்டமைக்கவும், பொதுவான queries efficient ஆக இருக்கின்றன, பெரும்பாலாக ஒரு single document read, SQL போல normalize-by-default செய்வதற்குப் பதிலாக) — இதுவே நல்ல MongoDB schema design-ஐ வேறுபடுத்துகிறது.

இது **denormalization** (duplication)-ஐ read efficiency-க்கு ஏற்றுக்கொள்வது என்பதைக் குறிக்கலாம், MongoDB-ல் ஏற்றுக்கொள்ளப்பட்ட மற்றும் பெரும்பாலாக சரியான update complexity-க்கு எதிரான trade-off.

Schema design என்பது MongoDB application performance மற்றும் maintainability-ஐ ஆழமாக பாதிக்கிறது (ஒரு மோசமான embed/reference தேர்வு slow queries, பெரிய documents, அல்லது update complexity ஏற்படுத்துகிறது), மற்றும் access-pattern-driven, embed-vs-reference approach என்பது SQL normalization-ல் இருந்து fundamentally வேறுபட்டது, MongoDB schema design — embed/reference முடிவு, ஒவ்வொன்றை எப்போது பயன்படுத்துவது, மற்றும் access patterns-க்கு design செய்வது — புரிந்துகொள்வது essential, high-value knowledge effective MongoDB applications கட்டுவதற்கு, ஒரு most important மற்றும் distinctive MongoDB topics-ல் ஒன்று, அவர்கள் நல்ல document schemas design செய்பவர்களை relational designs-ஐ naively port செய்பவர்களிடமிருந்து பிரிக்கிறது.