Bagaimanakah anda memodelkan perhubungan dalam MongoDB?

Question

Accepted Answer

MongoDB memodelkan perhubungan (one-to-one, one-to-many, many-to-many) melalui **embedding** atau **referencing** — pilihannya bergantung pada kardinaliti perhubungan, cara data dicapai, dan sama ada ia dikongsi. Tidak seperti pendekatan foreign key seragam SQL, MongoDB menawarkan fleksibiliti bagi setiap perhubungan.

## 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 (yang paling lazim — dan paling bernuansa)

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

Nuansa utama: **one-to-few** (embed), **one-to-many** (reference dari sisi many), **one-to-squillions** (sentiasa reference — jangan sekali-kali embed data tidak terbatas, kerana had dokumen 16MB dan prestasi).

## 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 menggunakan tatasusunan id yang dirujuk (pada satu atau kedua-dua sisi), atau collection seperti junction yang berasingan untuk data perhubungan yang kaya.

## Menyelesaikan rujukan ($lookup)

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

## Mengapa ia penting

Memodelkan perhubungan adalah asas kepada reka bentuk pangkalan data, dan pendekatan MongoDB yang fleksibel dan dipacu corak capaian berbeza daripada foreign key seragam SQL, jadi memahami cara memodelkan perhubungan dalam MongoDB adalah penting untuk mereka bentuk skema yang berkesan.

Wawasan utama ialah MongoDB memodelkan perhubungan melalui **embedding atau referencing** berdasarkan ciri perhubungan — dan memahami **bagaimana kardinaliti mempengaruhi pilihan** ialah kemahiran yang penting: **one-to-one** (biasanya embed — dicapai bersama), **one-to-many** dengan nuansa pentingnya (**one-to-few** → embed untuk data terbatas yang dicapai bersama; **one-to-many** → reference dari sisi many; **one-to-squillions** → sentiasa reference, tidak sekali-kali embed data tidak terbatas kerana had dokumen 16MB dan prestasi), dan **many-to-many** (tatasusunan id yang dirujuk, atau collection seperti junction).

Membuat keputusan yang dipacu kardinaliti ini (terutamanya mengenali bila data terlalu besar/tidak terbatas untuk di-embed) adalah penting untuk mengelakkan kesilapan lazim seperti embed tatasusunan tidak terbatas (membengkakkan dokumen, mencapai had) atau terlebih-reference data yang sepatutnya di-embed.

Memahami cara **menyelesaikan rujukan** dengan `$lookup` apabila join diperlukan melengkapkan gambaran tersebut.

Memandangkan perhubungan antara entiti adalah lumrah dalam kebanyakan model data, dan memandangkan pendekatan setiap-perhubungan MongoDB yang fleksibel (embed berbanding reference berdasarkan kardinaliti dan corak capaian) secara asasnya berbeza dan lebih bernuansa berbanding foreign key seragam SQL, memahami cara memodelkan perhubungan dalam MongoDB — keputusan embed/reference berasaskan kardinaliti (terutamanya perbezaan one-to-few/many/squillions) dan menyelesaikan rujukan — adalah pengetahuan penting yang kerap digunakan untuk reka bentuk skema MongoDB yang berkesan, membina di atas asas embed/reference untuk mengendalikan perhubungan yang ada pada setiap aplikasi sebenar, dan satu bidang utama yang membezakan pemodelan MongoDB yang baik daripada terjemahan relasi yang naif.