มี data modeling pattern ทั่วไปอะไรบ้างใน MongoDB?

Question

Accepted Answer

นอกเหนือจากการตัดสินใจพื้นฐานระหว่างการ embed กับการ reference แล้ว MongoDB ยังมี **data modeling pattern** ที่ได้รับการยอมรับ — โซลูชันที่พิสูจน์แล้วสำหรับสถานการณ์ทั่วไป เช่น array ขนาดใหญ่, ข้อมูลแบบ polymorphic และความสัมพันธ์ การรู้จักมันช่วยให้คุณออกแบบ schema ที่มีประสิทธิภาพสำหรับสถานการณ์จริง

## Bucket pattern — จัดกลุ่มข้อมูล time-series/ข้อมูลที่เกี่ยวข้องกัน

```js
// instead of one document per reading (millions of tiny docs), BUCKET them:
{
  sensorId: "s1",
  date: ISODate("2024-01-15"),
  readings: [                            // a day's readings in one document
    { time: "10:00", value: 23 },
    { time: "10:01", value: 24 }
  ]
}
// → fewer documents, efficient for time-series/IoT data
```

## Subset pattern — embed เฉพาะส่วนที่ใช้บ่อย

```js
// embed the most-used part, reference the rest (for large related data)
{
  _id: ObjectId("..."),
  title: "Product",
  recentReviews: [ /* 5 most recent — embedded for fast display */ ],
  // full reviews live in a separate collection (referenced)
}
// → fast common reads without loading ALL related data
```

## Computed pattern — คำนวณล่วงหน้าและเก็บไว้

```js
// store precomputed values (avoid recomputing on every read)
{ productId: "p1", totalReviews: 1500, avgRating: 4.5 }
// → update these when reviews change; reads are fast (no aggregation needed)
```

## Extended Reference pattern — embed ฟิลด์อ้างอิงที่สำคัญ

```js
// embed the OFTEN-NEEDED fields of a referenced document (avoid a join for common reads)
{ orderId: "o1", customer: { _id: "u1", name: "Ann", city: "NY" } }  // enough for display
// → reference customer._id for full data; embed name/city for the common read
```

## Pattern อื่น ๆ

```text
Polymorphic    → different document shapes in one collection (with a "type" field)
Schema Versioning → a version field to handle evolving schemas in one collection
Outlier        → handle rare documents that don't fit the common pattern specially
Approximation  → store approximate values (e.g. view counts) to reduce write load
Tree/Hierarchy → patterns for hierarchical data (parent refs, arrays of ancestors, etc.)
```

## ทำไมจึงสำคัญ

การเข้าใจ data modeling pattern ทั่วไปของ MongoDB มีคุณค่าสำหรับ **การออกแบบ schema ที่มีประสิทธิภาพสำหรับสถานการณ์ในโลกจริง** จึงเป็นความรู้ที่มีประโยชน์ซึ่งต่อยอดจากการตัดสินใจพื้นฐานระหว่างการ embed กับการ reference

แม้ว่าการ embed กับการ reference จะเป็นการเลือกหลัก แต่แอปพลิเคชันจริงต้องเผชิญกับความท้าทายในการ modeling ที่เกิดขึ้นซ้ำ ๆ ซึ่ง pattern ที่พิสูจน์แล้วเหล่านี้ตอบโจทย์ได้ ได้แก่ **Bucket pattern** (จัดกลุ่มข้อมูล time-series/IoT ลงในเอกสารที่น้อยลง — สำคัญสำหรับ use case ของ time-series ที่พบบ่อย หลีกเลี่ยงเอกสารเล็ก ๆ นับล้าน), **Subset pattern** (embed ส่วนที่ใช้บ่อยขณะอ้างอิงข้อมูลเต็ม — สร้างสมดุลระหว่างประสิทธิภาพการอ่านกับขนาดเอกสารสำหรับข้อมูลที่เกี่ยวข้องขนาดใหญ่), **Computed pattern** (คำนวณล่วงหน้าและเก็บค่าเช่น ผลรวม/ค่าเฉลี่ย เพื่อหลีกเลี่ยงการคำนวณซ้ำที่มีต้นทุนสูงตอนอ่าน), **Extended Reference pattern** (embed ฟิลด์ที่ต้องใช้บ่อยของเอกสารที่อ้างอิง เพื่อหลีกเลี่ยง join สำหรับการอ่านทั่วไป — เป็นแนวทางผสมที่ใช้งานได้จริง) และอื่น ๆ (polymorphic สำหรับรูปแบบที่หลากหลาย, schema versioning สำหรับการพัฒนาเปลี่ยนแปลง, tree pattern สำหรับลำดับชั้น)

การรู้จัก pattern เหล่านี้ให้ **โซลูชันที่พิสูจน์แล้ว** สำหรับสถานการณ์ทั่วไป แทนที่จะคิดออกแบบใหม่ทุกครั้ง ช่วยให้คุณตัดสินใจในการ modeling ได้อย่างถูกต้องสำหรับสถานการณ์เช่น ข้อมูล time-series, collection ที่เกี่ยวข้องขนาดใหญ่, การคำนวณที่มีต้นทุนสูง และข้อมูลแบบลำดับชั้น

เนื่องจากแอปพลิเคชัน MongoDB จริงต้องเผชิญกับความท้าทายในการออกแบบที่เกิดขึ้นซ้ำ ๆ เหล่านี้ และเนื่องจาก pattern ที่ได้รับการยอมรับให้โซลูชันที่ผ่านการทดสอบและมีประสิทธิภาพ (ปรับปรุงทั้งประสิทธิภาพและการบำรุงรักษา) การเข้าใจ data modeling pattern ทั่วไปของ MongoDB — bucket, subset, computed, extended reference และ pattern อื่น ๆ — จึงเป็นความรู้ที่มีคุณค่าและเกี่ยวข้องในทางปฏิบัติ ซึ่งยกระดับการออกแบบ schema จากการเลือก embed/reference พื้นฐานไปสู่การประยุกต์ใช้โซลูชันที่พิสูจน์แล้วสำหรับสถานการณ์จริง สะท้อนถึงทักษะการออกแบบ MongoDB ที่เป็นผู้ใหญ่ และช่วยสร้าง schema ที่ทำงานได้ดีตามรูปแบบการเข้าถึงและลักษณะข้อมูลเฉพาะของแอปพลิเคชัน