← Back to Curriculum

MongoDB Data Modeling

📚 Lesson 7 of 15 ⏱️ 45 min

MongoDB Data Modeling

45 min

MongoDB data modeling requires different approaches than relational databases due to its document-based, schema-less nature. Effective MongoDB data modeling balances embedding (storing related data in the same document) with referencing (storing references to related documents). The choice between embedding and referencing depends on data access patterns, relationship cardinality, data growth patterns, and query requirements. Understanding these patterns enables you to design efficient MongoDB schemas.

Embedding is ideal for one-to-one or one-to-few relationships where related data is frequently accessed together. Embedded documents reduce the need for joins, improving read performance. However, embedded documents increase document size and can lead to document growth issues. Embedding works well for data that doesn't change frequently and is always accessed with the parent document. Understanding when to embed enables efficient data access patterns.

Referencing uses ObjectId references to link documents across collections, similar to foreign keys in relational databases. Referencing is ideal for one-to-many or many-to-many relationships, large related data, or data that changes frequently. Referencing requires application-level joins using $lookup in aggregation or multiple queries. Understanding when to reference enables flexible, scalable data models.

Hybrid approaches combine embedding and referencing, embedding summary or frequently-accessed data while referencing detailed or less-frequently-accessed data. For example, a product document might embed basic specifications but reference detailed reviews. Hybrid approaches balance performance with flexibility. Understanding hybrid patterns enables optimal schema design for complex requirements.

Common data modeling patterns include tree structures (using parent references or materialized paths), polymorphic documents (documents with different structures in the same collection), and bucket patterns (grouping related data into buckets to avoid document growth). Each pattern addresses specific use cases and trade-offs. Understanding these patterns enables you to model complex domains effectively.

Best practices for MongoDB data modeling include designing for your access patterns (optimize for how data is read, not just how it's written), avoiding deep nesting (limit nesting to 2-3 levels), monitoring document size (stay well below 16MB limit), and considering write patterns (embedding makes updates more expensive). Understanding these practices enables you to design schemas that perform well and scale effectively.

Key Concepts

  • MongoDB data modeling balances embedding vs referencing.
  • Embedding is ideal for one-to-one or one-to-few relationships.
  • Referencing is ideal for one-to-many or many-to-many relationships.
  • Hybrid approaches combine embedding and referencing.
  • Data modeling should optimize for access patterns.

Learning Objectives

Master

  • Understanding when to embed vs reference data
  • Designing schemas for different relationship types
  • Applying common MongoDB data modeling patterns
  • Balancing performance with flexibility

Develop

  • Understanding NoSQL data modeling principles
  • Designing efficient document schemas
  • Optimizing for access patterns

Tips

  • Embed data that's always accessed together for better read performance.
  • Reference data that's large, changes frequently, or has many relationships.
  • Use hybrid approach: embed summaries, reference details.
  • Design for your read patterns, not just write patterns.

Common Pitfalls

  • Over-embedding, causing document growth and update issues.
  • Over-referencing, requiring too many queries or $lookup operations.
  • Not considering access patterns, creating inefficient schemas.
  • Ignoring document size limits, approaching 16MB limit.

Summary

  • MongoDB data modeling differs from relational databases.
  • Embedding vs referencing depends on relationship and access patterns.
  • Common patterns address specific use cases and trade-offs.
  • Effective modeling optimizes for read patterns.

Exercise

Design data models for different scenarios using MongoDB patterns.

// Pattern 1: Embedding (One-to-Few)
// Good for small, related data that doesn't change often
db.products.insertOne({
  _id: ObjectId(),
  name: "Laptop",
  price: 999.99,
  specifications: {
    brand: "Dell",
    model: "XPS 13",
    processor: "Intel i7",
    ram: "16GB",
    storage: "512GB SSD"
  },
  reviews: [
    { user: "user1", rating: 5, comment: "Great laptop!", date: new Date() },
    { user: "user2", rating: 4, comment: "Good performance", date: new Date() }
  ]
})

// Pattern 2: Referencing (One-to-Many)
// Good for large, frequently changing data
db.orders.insertOne({
  _id: ObjectId(),
  customerId: ObjectId("customer_id_here"),
  items: [
    { productId: ObjectId("product_id_1"), quantity: 2, price: 999.99 },
    { productId: ObjectId("product_id_2"), quantity: 1, price: 699.99 }
  ],
  total: 2699.97,
  status: "completed",
  createdAt: new Date()
})

// Pattern 3: Hybrid Approach
db.products.insertOne({
  _id: ObjectId(),
  name: "Smartphone",
  price: 699.99,
  category: "Electronics",
  // Embed small, frequently accessed data
  specifications: {
    brand: "Apple",
    model: "iPhone 15",
    storage: "128GB"
  },
  // Reference large, less frequently accessed data
  reviews: [
    { reviewId: ObjectId("review_id_1") },
    { reviewId: ObjectId("review_id_2") }
  ],
  // Embed summary data
  reviewSummary: {
    averageRating: 4.5,
    totalReviews: 150
  }
})

// Pattern 4: Tree Structure
db.categories.insertOne({
  _id: ObjectId(),
  name: "Electronics",
  path: "Electronics",
  level: 1,
  children: [
    {
      _id: ObjectId(),
      name: "Computers",
      path: "Electronics.Computers",
      level: 2,
      children: [
        {
          _id: ObjectId(),
          name: "Laptops",
          path: "Electronics.Computers.Laptops",
          level: 3
        }
      ]
    }
  ]
})

// Pattern 5: Polymorphic Documents
db.content.insertMany([
  {
    _id: ObjectId(),
    type: "article",
    title: "Getting Started with MongoDB",
    content: "MongoDB is a NoSQL database...",
    author: "John Doe",
    publishedAt: new Date()
  },
  {
    _id: ObjectId(),
    type: "video",
    title: "MongoDB Tutorial",
    content: "video_url_here",
    duration: 1200,
    creator: "Jane Smith",
    uploadedAt: new Date()
  }
])

Exercise Tips

  • Use embedding for one-to-few relationships that are accessed together.
  • Use referencing for one-to-many relationships or frequently changing data.
  • Consider document size: keep documents well below 16MB limit.
  • Use materialized paths for tree structures: { path: 'Electronics.Computers.Laptops' }.

Code Editor

Output