Building with Patterns in MongoDB

Building with Patterns in MongoDB refers to the strategic and thoughtful application of design patterns to enhance the efficiency, scalability, and maintainability of database structures. MongoDB, being a flexible and schema-less NoSQL database, encourages the adoption of patterns tailored to specific use cases. The Building with Patterns approach involves understanding the data access patterns of an application and crafting MongoDB schemas that align with these patterns. Common patterns include the use of Embedded Data Models for one-to-many relationships, the Bucket Pattern for time-series data, and the Outlier Pattern for handling outliers in datasets. By leveraging these patterns, developers can optimize query performance, simplify data retrieval, and ensure the scalability of MongoDB databases. This approach facilitates the creation of robust, adaptable, and high-performance database solutions tailored to the unique requirements of each application.

Approximation        

The Approximation Pattern is useful when expensive calculations are frequently done and when the precision of those calculations is not the highest priority.

Pros

• Fewer writes to the database.
• Maintain statistically valid numbers.

Cons

• Exact numbers aren’t being represented.
• Implementation must be done in the application.

Attribute        

The Attribute Pattern is useful for problems that are based around having big documents with many similar fields but there is a subset of fields that share common characteristics and we want to sort or query on that subset of fields. When the fields we need to sort on are only found in a small subset of documents. Or when both of those conditions are met within the documents.

Pros

• Fewer indexes are needed.
• Queries become simpler to write and are generally faster.

Bucket

The Bucket Pattern is a great solution for when needing to manage streaming data, such as time-series, real-time analytics, or Internet of Things (IoT) applications.

Pros

• Reduces the overall number of documents in a collection.
• Improves index performance.
• Can simplify data access by leveraging pre-aggregation.

Computed        

When there are very read intensive data access patterns and that data needs to be repeatedly computed by the application, the Computed Pattern is a great option to explore.

Pros

• Reduction in CPU workload for frequent computations.
• Queries become simpler to write and are generally faster.

Cons

• It may be difficult to identify the need for this pattern.
• Applying or overusing the pattern should be avoided unless needed.

Document Versioning        

When you are faced with the need to maintain previous versions of documents in MongoDB, the Document Versioning pattern is a possible solution.

Pros

• Easy to implement, even on existing systems.
• No performance impact on queries on the latest revision.

Cons

• Doubles the number of writes.
• Queries need to target the correct collection.

Extended Reference        

You will find the Extended Reference pattern most useful when your application is experiencing lots of JOIN operations to bring together frequently accessed data.

Pros

• Improves performance when there are a lot of JOIN operations.
• Faster reads and a reduction in the overall number of JOINs.

Cons

• Data duplication.

Outlier        

Do you find that there are a few queries or documents that don’t fit into the rest of your typical data patterns? Are these exceptions driving your application solution? If so, the Outlier Pattern is a wonderful solution to this situation.

Pros

• Prevents a few documents or queries from determining an application’s solution.
• Queries are tailored for “typical” use cases, but outliers are still addressed.

Cons

• Often tailored for specific queries, therefore ad hoc queries may not perform well.
• Much of this pattern is done with application code.

Pre-allocation        

When you know your document structure and your application simply needs to fill it with data, the Pre-Allocation Pattern is the right choice.

Pros

• Design simplification when the document structure is known in advance.

Cons

• Simplicity versus performance.

Polymorphic        

The Polymorphic Pattern is the solution when there are a variety of documents that have more similarities than differences and the documents need to be kept in a single collection.

Pros

• Easy to implement.
• Queries can run across a single collection.

Schema Versioning        

Just about every application can benefit from the Schema Versioning Pattern as changes to the data schema frequently occur in an application’s lifetime. This pattern allows for previous and current versions of documents to exist side by side in a collection.

Pros

• No downtime needed.
• Control of schema migration.
• Reduced future technical debt.

Cons

• Might need two indexes for the same field during migration.

Subset        

The Subset Pattern solves the problem of having the working set exceed the capacity of RAM due to large documents that have much of the data in the document not being used by the application.

Pros

• Reduction in the overall size of the working set.
• Shorter disk access time for the most frequently used data.

Cons

• We must manage the subset.
• Pulling in additional data requires additional trips to the database.

Tree        

When data is of a hierarchical structure and is frequently queried, the Tree Pattern is the design pattern to implement.

Pros

• Increased performance by avoiding multiple JOIN operations.

Cons

• Updates to the graph need to be managed in the application.

Conclusion        

The MongoDB document model offers significant flexibility in data modeling, providing a powerful tool for developers. However, this flexibility must be carefully channeled to align with the specific data access patterns of your application. It's crucial to recognize that the schema design in MongoDB significantly impacts the performance of your application, and performance issues often stem from inadequate schema design. To maximize the potential of the document model, consider utilizing schema design patterns in conjunction with each other, as appropriate. For instance, Schema Versioning can complement other patterns as your application evolves. This article covers twelve schema design patterns, equipping you with the tools and knowledge necessary to effectively leverage the flexibility inherent in the MongoDB document model.