Vaibhav Rathod's Notes

MongoDB

5 min read

History

- **How**:
	- **MongoDB** was first developed in **2007** by **Dwight Merriman**, **Eliot Horowitz**, and **Kevin Ryan** as part of the **10gen** company (now MongoDB, Inc.).
	- MongoDB was designed to address the limitations of traditional relational databases, especially in terms of scalability, flexibility, and ease of use when handling large volumes of unstructured or semi-structured data.
	- MongoDB is a **NoSQL** database that stores data in a **document-oriented** format, specifically **BSON** (Binary JSON). This allows for more flexible schema designs and better support for modern web applications.
	- MongoDB was created with the goal of providing a database system that is highly **scalable**, **flexible**, and **easy to use**, especially for applications that require fast read and write operations, such as web apps, real-time analytics, and big data systems.
-
- **Who**:
	- MongoDB was created by **Dwight Merriman**, **Eliot Horowitz**, and **Kevin Ryan**, co-founders of **10gen** (now MongoDB, Inc.), a company that focuses on building and supporting MongoDB.
	- The project is now maintained by **MongoDB, Inc.**, with contributions from a large global community of developers and engineers.
	- MongoDB has become one of the most popular NoSQL databases in the world, especially in the context of modern web development.
-
- **Why**:
	- MongoDB was created to address the need for a highly scalable, flexible, and performant database system that can handle large, rapidly changing datasets in modern web applications.
	- Its design was motivated by the increasing need to work with unstructured or semi-structured data, and the growing demand for databases that could scale out horizontally across distributed systems.
	- MongoDB was built with the intention of offering better support for **big data**, **real-time applications**, and **dynamic schema** environments, where traditional relational databases faced limitations.

-

  • Introduction

    • Advantages :

      • Flexible Schema: MongoDB’s document-based structure allows for a dynamic schema, meaning you can store different types of data in the same collection without needing to define a fixed schema in advance. This is especially useful for rapidly evolving applications.
      • Scalability: MongoDB is designed for horizontal scalability, making it easy to scale out across multiple servers using sharding. This allows it to handle large amounts of data and high throughput while maintaining performance.
      • High Availability: MongoDB supports replication, allowing for high availability and automatic failover. This ensures that your database is fault-tolerant and can recover quickly from server failures.
      • Performance: MongoDB provides high performance for read and write operations, especially for workloads that require fast access to large datasets, such as real-time analytics and content management systems.
      • JSON-Like Documents: MongoDB stores data in BSON (Binary JSON), which is similar to JSON but includes more data types, allowing for efficient storage and retrieval of complex data structures.
      • Aggregation Framework: MongoDB includes a powerful aggregation framework, allowing developers to perform complex queries, transformations, and computations on data within the database itself, reducing the need for additional processing on the application side.
      • Geospatial Indexing: MongoDB offers built-in support for geospatial queries and indexing, enabling location-based queries for applications such as mapping, logistics, and geo-aware apps.

    • Disadvantages :

      • Lack of ACID Transactions (Earlier Versions): While recent versions of MongoDB have introduced multi-document ACID transactions, earlier versions lacked full ACID compliance, making it less suitable for use cases that require strict consistency and transactional guarantees.
      • Complex Queries: MongoDB’s querying capabilities, while powerful, can sometimes be less intuitive or more complex compared to relational databases, especially for advanced join operations. It does not natively support complex JOINs as relational databases do.
      • Memory Usage: MongoDB’s in-memory data handling can lead to high memory consumption, especially with large datasets, which may require careful system configuration and optimization.
      • Data Redundancy: Because MongoDB’s model is designed for flexibility, developers sometimes store redundant data across multiple documents to reduce the complexity of queries, leading to potential data duplication and challenges in maintaining consistency.
      • Limited Join Operations: MongoDB supports some types of joins using the $lookup operator, but its join capabilities are more limited compared to relational databases. Complex relationships between documents are more difficult to model and query.

    • Remember Points :

      • Schema Flexibility: MongoDB’s flexible, document-based schema is ideal for applications that need to evolve quickly or handle diverse, unstructured data types.
      • Horizontal Scalability: MongoDB’s architecture supports sharding for distributing data across multiple servers, making it highly scalable and capable of handling large datasets and high-throughput applications.
      • Replication and High Availability: MongoDB’s replication features ensure that data is available even in the event of hardware failure, making it a reliable choice for mission-critical applications.
      • Aggregation Framework: MongoDB’s powerful aggregation framework allows you to perform complex operations on data within the database itself, reducing the need for heavy application-side processing.
      • Geospatial Support: MongoDB includes support for geospatial queries and indexing, making it a strong choice for applications that require location-based data processing.
      • Evolving Database: MongoDB is well-suited for use cases that involve frequent schema changes, large-scale data storage, and agile development cycles.

Graph View

Backlinks