Document size and growth patterns in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Calculate average document size in a collection

Given a MongoDB collection named orders, which aggregation pipeline will correctly calculate the average size in bytes of documents stored in this collection?

A [{ $group: { _id: null, avgSize: { $avg: { $bsonSize: "$ROOT" } } } }]

B [{ $project: { size: { $strLenCP: "$ROOT" } } }, { $group: { _id: null, avgSize: { $avg: "$size" } } }]

C [{ $project: { size: { $bsonSize: "$ROOT" } } }, { $group: { _id: null, avgSize: { $avg: "$size" } } }]

D [{ $count: "totalDocs" }, { $group: { _id: null, avgSize: { $avg: "$totalDocs" } } }]

💡 Hint

Use $bsonSize to get the size of each document in bytes before averaging.

Option C first projects the size of each document using $bsonSize, then groups all documents to calculate the average size. Option C tries to use $bsonSize inside $avg directly, which is not allowed. Option C uses $strLenCP which measures string length, not document size. Option C counts documents but does not calculate size.

🧠 Conceptual

intermediate

Understanding document growth and padding

In MongoDB, when a document grows in size due to updates, what mechanism helps reduce the need for document moves and fragmentation?

A Pre-allocating padding space around documents to accommodate growth

B Automatically compressing documents on disk

C Storing documents in fixed-size blocks without padding

D Using indexes to store document size metadata

💡 Hint

Think about how MongoDB avoids moving documents when they grow slightly.

MongoDB pre-allocates extra space (padding) around documents to allow them to grow without moving. This reduces fragmentation and improves update performance. Compression and indexes do not directly affect document growth handling.

📝 Syntax

advanced

Identify the correct syntax to find documents larger than 16MB

Which MongoDB query correctly finds documents in the files collection whose BSON size exceeds 16 megabytes (16 * 1024 * 1024 bytes)?

A db.files.find({ size: { $gt: 16777216 } })

B db.files.find({ $expr: { $gt: [ { $bsonSize: "$ROOT" }, 16777216 ] } })

C db.files.find({ $bsonSize: { $gt: 16777216 } })

D db.files.aggregate([{ $match: { $bsonSize: { $gt: 16777216 } } }])

💡 Hint

Use $expr to compare computed values in queries.

Option B uses $expr with $bsonSize to compute document size and compare it to 16MB correctly. Option B tries to use $bsonSize as a query operator which is invalid. Option B queries a non-existent field 'size'. Option B uses aggregation syntax incorrectly inside find.

🔧 Debug

advanced

Why does this update cause document move despite padding?

A document in MongoDB has padding to allow growth. However, after an update that adds a large array, the document moves to a new location. What is the most likely reason?

A The document was indexed and indexes prevent moves

B The update used $set instead of $push

C MongoDB does not support document moves after creation

D The update increased the document size beyond the allocated padding space

💡 Hint

Consider the size limits of padding space.

Padding space is limited. If the document grows beyond this space, MongoDB must move it to a new location. Indexes do not prevent moves. MongoDB supports moves when necessary. The update operator used does not affect move necessity.

❓ optimization

expert

Optimizing document growth to reduce fragmentation

You have a collection where documents frequently grow due to added fields and arrays. Which approach best reduces document moves and fragmentation over time?

A Design documents with reserved fields or arrays pre-allocated with empty values

B Use smaller documents and split data into multiple collections

C Disable padding factor to save disk space

D Use capped collections to limit document size

💡 Hint

Think about how to prepare documents for growth in advance.

Pre-allocating fields or arrays with empty values reserves space inside documents, reducing moves when data is added. Smaller documents and splitting data help but do not directly reduce moves. Disabling padding increases moves. Capped collections have fixed size and do not allow growth.