MongoDB中如何限制返回子文档的查询深度？

Great question! When dealing with hierarchical time-series data like this in MongoDB, you’ve got a few solid approaches to limit the returned subdocument depth and fetch only the data you need. Let’s break them down:

1. Use Projection to Explicitly Select Needed Fields #

MongoDB’s projection feature lets you specify exactly which parts of the document you want returned, skipping deeper subdocuments entirely.

Assuming your document structure looks something like this (using arrays for months/days for flexibility):

{
  "_id": ObjectId("..."),
  "year": 2018,
  "months": [
    {
      "month": 1,
      "total_data": 456789,
      "days": [
        {
          "day": 1,
          "hours": [/* hour/minute-level data */]
        }
      ]
    },
    // ... other months
  ]
}

To fetch only 2018’s months and their total data (ignoring days/hours), your query would look like this:

db.data_usage.find(
  { year: 2018 }, // Match the target year
  { 
    "_id": 0, // Exclude the default _id field
    "months.month": 1, // Include month number
    "months.total_data": 1 // Include monthly total
  }
)

This will return a clean document with just the year and its monthly totals, no deeper nested data. If your structure uses nested objects instead of arrays (e.g., {year:2018, "1": {total_data: ...}, "2": {...}}), adjust the projection to target those keys directly:

db.data_usage.find(
  { year: 2018 },
  { "_id": 0, "1.total_data": 1, "2.total_data": 1 /* ... include other months */ }
)

2. Use the Aggregation Framework for Calculations & Custom Output #

If you don’t pre-store monthly totals and need to calculate them on the fly (or want more control over the output structure), the aggregation framework is your friend.

For example, to calculate 2018’s monthly totals from day-level data:

db.data_usage.aggregate([
  // Step 1: Filter to only 2018 data
  { $match: { year: 2018 } },
  // Step 2: Unwind the months array to process each month individually
  { $unwind: "$months" },
  // Step 3: Calculate the monthly total by summing day-level totals
  { $addFields: {
    "months.monthly_total": { $sum: "$months.days.total_data" }
  } },
  // Step 4: Keep only the fields we care about
  { $project: {
    "_id": 0,
    "year": 1,
    "month": "$months.month",
    "total_data": "$months.monthly_total"
  } },
  // Optional: Group back into a single document with a months array
  { $group: {
    "_id": "$year",
    "months": { $push: { month: "$month", total_data: "$total_data" } }
  } }
])

This pipeline will return exactly the aggregated monthly totals you need, without pulling in any hour/minute-level data.

3. Pre-Aggregate Data for Long-Term Performance #

As you refine your data to the minute level, your documents will grow significantly, and real-time aggregations could become slow. A proactive solution is to pre-aggregate totals at each level (year → month → day → hour) and store them directly in your documents.

For example:

• Use a scheduled script or MongoDB Atlas Triggers to run nightly aggregations.
• Update each month’s total_data field by summing the day-level totals, each day’s total by summing hour-level data, etc.

This way, when you need monthly totals, you can just use the projection method from point 1—no real-time calculations needed, making queries fast even with massive datasets.

内容的提问来源于stack exchange，提问作者Ryan de Kock