presudo 1.0.0

package/pods/db/mongo.txt

@@ -0,0 +1,842 @@
+                                        MongoDB: Comprehensive Notes for Beginners 📚
+1. What is MongoDB?
+
+MongoDB is a document-oriented, NoSQL database that stores data in a flexible, JSON-like format called BSON. 
+It is designed to scale horizontally across many servers and supports high availability.
+
+-------------------------------------------------------------------------------------------------------------------------
+2. Advantages of MongoDB
+
+Scalability: Horizontally scalable through sharding.
+
+Flexibility: Schema-less design; easy to change data structures.
+
+High Availability: Achieved through replica sets.
+
+Rich Query Language: MongoDB offers powerful querying and aggregation capabilities.
+
+High Performance: Fast writes and reads with appropriate indexing.
+
+-------------------------------------------------------------------------------------------------------------------------
+
+3. MongoDB Architecture
+
+MongoDB is based on a client-server architecture:
+
+Client: MongoDB applications or tools like mongo shell or Compass.
+
+Server: MongoDB instance (where data is stored).
+
+Database: A collection of data.
+
+Collection: A grouping of documents, similar to a table in relational databases.
+
+Document: A record in a collection, stored in BSON format (Binary JSON).
+
+-------------------------------------------------------------------------------------------------------------------------
+1. Auto-Sharding in NoSQL Databases
+
+Auto-sharding is a technique used in NoSQL databases to distribute large datasets across multiple servers or nodes.
+ The database automatically splits the data and allocates it to different servers to balance the load. This allows the database to scale horizontally by adding more servers as data grows.
+
+Example in MongoDB: MongoDB uses shards to store data across multiple machines.
+ A shard key determines how data is distributed across shards.
+-------------------------------------------------------------------------------------------------------------------------
+
+2. Loading the Data and Query Automatically Across Servers
+
+In NoSQL databases with sharding (like MongoDB), when data is loaded or queried, 
+the system automatically distributes the data to the appropriate shard and routes the query to the correct server. 
+This automatic distribution ensures that the database can scale horizontally and handle large amounts of data.
+-------------------------------------------------------------------------------------------------------------------------
+
+3. Sharing of Complex Data
+
+Complex data refers to large datasets that may contain nested structures, arrays, 
+or other complex types. NoSQL databases are designed to store and efficiently manage these complex data types. 
+Sharing complex data across distributed systems requires strategies like:
+
+Sharding: Data is split across multiple nodes based on a shard key.
+
+Replication: Copies of the data are maintained on multiple servers for high availability.
+-------------------------------------------------------------------------------------------------------------------------
+
+4. Dependency of CAP Model on BASE Theorem
+
+The CAP Theorem states that in a distributed system, you can only achieve two 
+out of three properties: Consistency, Availability, and Partition tolerance.
+ NoSQL databases generally focus on Availability and Partition tolerance (i.e., the BASE model).
+
+BASE (Basically Available, Soft state, Eventually consistent) 
+is a more relaxed consistency model compared to ACID (Atomicity, Consistency, Isolation, Durability).
+
+Basically Available: The system guarantees availability.
+
+Soft State: The state of the system can change over time.
+
+Eventually Consistent: The system will become consistent at some point.
+-------------------------------------------------------------------------------------------------------------------------
+
+5. Updating a Document
+
+In NoSQL databases like MongoDB, updating a document is straightforward.
+ MongoDB uses an update operation to modify fields in an existing document.
+
+Example:
+
+db.collection.updateOne({ _id: 1 }, { $set: { status: "Active" } });
+-------------------------------------------------------------------------------------------------------------------------
+
+6. Understanding MongoDB Queries
+
+MongoDB provides a rich query language that allows you to filter, sort, and project data. 
+Key components of MongoDB queries include:
+
+find(): Retrieves documents based on a query.
+
+sort(): Sorts the result set.
+
+limit(): Limits the number of documents returned.
+
+Example:
+
+db.users.find({ age: { $gt: 20 } }).sort({ name: 1 }).limit(10);
+-------------------------------------------------------------------------------------------------------------------------
+
+7. Working on a Distributed Transaction
+
+A distributed transaction involves multiple operations across different nodes or services. 
+NoSQL databases like MongoDB support multi-document ACID transactions to ensure that operations across multiple documents or collections are atomic, consistent, isolated, and durable.
+
+Example: You start a transaction with startSession(), and if all operations succeed, 
+you commit the transaction; otherwise, you abort it.
+-------------------------------------------------------------------------------------------------------------------------
+
+8. Selecting Documents from a Collection
+
+In MongoDB, selecting documents is done using the find() function. 
+You can specify filters, projections, sorting, and limiting to retrieve the data you need.
+
+Example:
+
+db.collection.find({ age: { $gt: 25 } }).sort({ name: 1 }).limit(5);
+-------------------------------------------------------------------------------------------------------------------------
+
+9. Deploying Replica Sets
+
+A replica set in MongoDB is a group of MongoDB instances that maintain the same data set. 
+Replica sets provide high availability and data redundancy.
+
+Steps to deploy a replica set:
+
+Configure multiple MongoDB instances to form the replica set.
+
+Elect a primary node and set up secondary nodes for replication.
+-------------------------------------------------------------------------------------------------------------------------
+
+10. Using the Master-Slave Replication Method
+
+In master-slave replication, one node (master) accepts write operations, and the other nodes (slaves) 
+replicate data from the master. This method is generally considered outdated, and MongoDB now uses replica sets instead,
+ which provide more redundancy and failover capabilities.
+-------------------------------------------------------------------------------------------------------------------------
+
+11. Data Replication in NoSQL
+
+Data replication involves copying data from one node to another for high availability and fault tolerance. 
+In NoSQL databases, replication can be done in several ways:
+
+Master-slave replication: Data is replicated from a master node to multiple slave nodes.
+
+Peer-to-peer replication: All nodes are equal, and data is replicated between all nodes.
+-------------------------------------------------------------------------------------------------------------------------
+
+12. Defining Nested Key Named Type
+
+In NoSQL databases, particularly document-based databases like MongoDB,
+ you can define nested fields within documents. These fields can have their own structure,
+  which is different from flat relational data models.
+
+Example:
+
+{ _id: 1, name: "John", address: { street: "123 Main St", city: "New York" } }
+-------------------------------------------------------------------------------------------------------------------------
+
+13. Debugging a Piece of Code
+
+Debugging in NoSQL systems involves identifying issues with queries, data modeling, 
+or network operations. Tools like MongoDB Compass, logs, and profiler can help debug and optimize queries.
+-------------------------------------------------------------------------------------------------------------------------
+
+14. Using the Replication Scheme
+
+Replication schemes in NoSQL databases, especially in MongoDB, ensure that data 
+is consistently copied to multiple servers for fault tolerance and high availability. 
+The replication setup can include primary and secondary nodes, where the primary node handles all write operations, 
+and secondary nodes replicate data.
+-------------------------------------------------------------------------------------------------------------------------
+
+15. Performing Complex Transactions which Require Multiple Operations
+
+NoSQL databases like MongoDB support multi-document transactions,
+ which ensure that a group of operations across multiple documents or collections is executed atomically.
+
+Example:
+
+const session = client.startSession();
+session.startTransaction();
+try {
+  db.collection.updateOne({ _id: 1 }, { $set: { status: "Active" } }, { session });
+  db.collection.updateOne({ _id: 2 }, { $set: { status: "Inactive" } }, { session });
+  session.commitTransaction();
+} catch (error) {
+  session.abortTransaction();
+} finally {
+  session.endSession();
+}
+-------------------------------------------------------------------------------------------------------------------------
+
+16. NoSQL Storage Partitions
+
+Storage partitions in NoSQL databases refer to splitting data across 
+different servers (partitions or shards). This partitioning allows the database to scale horizontally, 
+ensuring it can handle larger datasets effectively.
+-------------------------------------------------------------------------------------------------------------------------
+
+17. NoSQL Scenarios
+
+NoSQL databases are particularly suitable for the following scenarios:
+
+Handling unstructured or semi-structured data.
+
+Managing large volumes of data that need to be scaled horizontally.
+
+Applications that require low latency and high availability.
+-------------------------------------------------------------------------------------------------------------------------
+
+18. NoSQL Operations
+
+NoSQL databases like MongoDB offer basic operations such as:
+
+Create: Inserting documents into collections.
+
+Read: Querying documents.
+
+Update: Modifying documents.
+
+Delete: Removing documents.
+-------------------------------------------------------------------------------------------------------------------------
+
+19. XML Retrieval Tools
+
+NoSQL databases, particularly those that support document-based models (like MongoDB), 
+allow you to store and retrieve data in various formats, including XML. XPath and XQuery 
+are tools commonly used for querying XML data.
+-------------------------------------------------------------------------------------------------------------------------
+
+20. NoSQL Data Model Groupings
+
+NoSQL data models are often categorized into:
+
+Document store: (e.g., MongoDB) stores data as documents.
+
+Key-value store: (e.g., Redis) stores data as key-value pairs.
+
+Column-family store: (e.g., Cassandra) stores data in columns.
+
+Graph database: (e.g., Neo4j) stores data as nodes and edges.
+-------------------------------------------------------------------------------------------------------------------------
+
+21. Reasons for NoSQL Popularity
+
+NoSQL databases have become popular for reasons such as:
+
+Scalability: They scale horizontally, making them suitable for large-scale applications.
+
+Flexibility: Schema-less design allows easy changes to data structures.
+
+Performance: NoSQL databases offer high performance for certain types of workloads.
+-------------------------------------------------------------------------------------------------------------------------
+
+22. Graph Store Limitations
+
+Graph databases are designed for handling highly interconnected data. However, they may have limitations in terms of:
+
+Scalability: Graph databases may not scale as well horizontally as other NoSQL databases.
+
+Complexity: Querying complex graphs can be challenging.
+-------------------------------------------------------------------------------------------------------------------------
+
+23. MapR-DB Compatibility
+
+MapR-DB is a NoSQL database that provides support for both HBase and Cassandra APIs. It is optimized for performance and is typically used in big data and analytics workloads. MapR-DB is compatible with Hadoop and other big data technologies.
+-------------------------------------------------------------------------------------------------------------------------
+
+24. NoSQL Advantages
+
+Scalability: NoSQL databases can scale horizontally, making them ideal for large-scale applications.
+
+Performance: They are optimized for fast reads and writes.
+
+Flexibility: NoSQL allows schema-less and semi-structured data storage.
+-------------------------------------------------------------------------------------------------------------------------
+
+25. Configurations for Availability
+
+To ensure high availability in NoSQL databases, configurations such as replica sets and sharding are used.
+ Data is replicated across multiple nodes to ensure availability even if some nodes go down.
+-------------------------------------------------------------------------------------------------------------------------
+
+26. NoSQL Benefits
+
+Distributed Architecture: Facilitates scalability and high availability.
+
+Flexible Data Models: Handle structured, semi-structured, and unstructured data.
+
+Fast Writes: High throughput for writes.
+-------------------------------------------------------------------------------------------------------------------------
+
+27. First Step in NoSQL Adoption
+
+The first step in adopting a NoSQL database is understanding the data model and selecting the appropriate NoSQL 
+database (document, key-value, graph, etc.) based on your application's requirements.
+-------------------------------------------------------------------------------------------------------------------------
+
+28. NoSQL Data Modeling Techniques
+
+NoSQL databases offer different data modeling techniques based on the use case. Some common patterns are:
+
+Embedding: Store related data within the same document (good for one-to-one relationships).
+
+Referencing: Store related data in separate documents (good for one-to-many or many-to-many relationships).
+-------------------------------------------------------------------------------------------------------------------------
+
+29. Column Store Databases
+
+Column-store databases (e.g., Cassandra, HBase) store data by column rather than by row. 
+This approach is particularly beneficial for analytical queries where you often need to read only a few columns from a large dataset.
+-------------------------------------------------------------------------------------------------------------------------
+
+30. Distributed Transaction Cursors
+
+In distributed databases, a transaction cursor allows you to work with large datasets
+ in chunks, ensuring that the transaction is properly handled even when data is spread across multiple servers.
+
+-------------------------------------------------------------------------------------------------------------------------
+
+4. MongoDB Data Types
+
+MongoDB uses BSON (Binary JSON), which supports the following data types:
+
+String: Textual data.
+
+Integer: Whole numbers.
+
+Boolean: true or false.
+
+Double: Decimal values.
+
+Array: Ordered list of values.
+
+Object: A document within another document.
+
+Date: Date and time.
+
+Null: Empty value.
+
+ObjectId: Unique identifier for documents.
+
+Binary Data: For storing binary information.
+
+Regular Expression: For storing patterns.
+-------------------------------------------------------------------------------------------------------------------------
+
+5. CRUD Operations (Create, Read, Update, Delete)
+
+Create: Add new documents.
+
+insertOne(): Inserts a single document.
+
+insertMany(): Inserts multiple documents.
+
+Read: Query documents.
+
+find(): Retrieves documents that match specified criteria.
+
+findOne(): Retrieves a single document.
+
+countDocuments(): Counts the number of documents.
+
+Update: Modify existing documents.
+
+updateOne(): Updates one document.
+
+updateMany(): Updates multiple documents.
+
+replaceOne(): Replaces a document.
+
+Delete: Remove documents.
+
+deleteOne(): Deletes one document.
+
+deleteMany(): Deletes multiple documents.
+-------------------------------------------------------------------------------------------------------------------------
+
+6. Indexes in MongoDB
+
+Indexes improve query performance by allowing fast searching.
+
+Creating an Index:
+
+db.collection.createIndex({ field: 1 });  // Ascending index
+
+
+List Indexes:
+
+db.collection.getIndexes();
+
+
+Drop an Index:
+
+db.collection.dropIndex("index_name");
+-------------------------------------------------------------------------------------------------------------------------
+
+7. Aggregation Framework
+
+Aggregation allows you to process data records and return computed results:
+
+$match: Filters documents.
+
+$group: Groups documents by field.
+
+$sort: Sorts the results.
+
+$project: Modifies documents.
+
+$limit: Limits the number of documents.
+
+$skip: Skips a number of documents.
+
+$unwind: Deconstructs an array.
+
+Example aggregation pipeline:
+
+db.collection.aggregate([
+    { $match: { age: { $gt: 20 } } },
+    { $group: { _id: "$age", count: { $sum: 1 } } }
+]);
+-------------------------------------------------------------------------------------------------------------------------
+
+8. Sharding in MongoDB
+
+Sharding distributes data across multiple servers for horizontal scaling.
+
+Shard Key: Field used to distribute data.
+
+Shards: MongoDB instances where data is stored.
+
+Mongos: Query router responsible for routing client requests to the correct shard.
+
+Sharding is best suited for large datasets and high-traffic applications.
+-------------------------------------------------------------------------------------------------------------------------
+
+9. Replica Sets in MongoDB
+
+A replica set is a group of MongoDB servers that maintain the same data set.
+
+Primary: The main server handling reads and writes.
+
+Secondary: Copies of the primary that replicate data.
+
+Arbiter: A member that doesn't store data but helps with elections.
+-------------------------------------------------------------------------------------------------------------------------
+
+10. MongoDB Users and Roles
+
+MongoDB uses role-based access control (RBAC) to define permissions.
+
+Create User:
+
+db.createUser({
+    user: "username",
+    pwd: "password",
+    roles: [{ role: "readWrite", db: "mydb" }]
+});
+
+
+List Users:
+
+db.getUsers();
+
+
+Drop User:
+
+db.dropUser("username");
+-------------------------------------------------------------------------------------------------------------------------
+
+11. Backup and Restore
+
+Backup (mongodump):
+
+mongodump --uri="mongodb://localhost:27017" --out=/backup/dir
+
+
+Restore (mongorestore):
+
+mongorestore /backup/dir
+-------------------------------------------------------------------------------------------------------------------------
+
+12. MongoDB with Python (PyMongo)
+
+PyMongo is the official MongoDB driver for Python.
+
+Install PyMongo:
+
+pip install pymongo
+
+
+Connect to MongoDB:
+
+from pymongo import MongoClient
+client = MongoClient("mongodb://localhost:27017/")
+db = client.mydb
+
+
+Insert Data:
+
+db.collection.insert_one({"name": "Alice", "age": 30})
+
+
+Find Data:
+
+person = db.collection.find_one({"name": "Alice"})
+print(person)
+-------------------------------------------------------------------------------------------------------------------------
+
+13. MongoDB Query Operators
+
+$eq: Matches exact value.
+
+db.collection.find({ age: { $eq: 30 } });
+
+
+$gt, $gte: Greater than, greater than or equal to.
+
+db.collection.find({ age: { $gt: 20 } });
+
+
+$lt, $lte: Less than, less than or equal to.
+
+$in: Matches any value in a list.
+
+db.collection.find({ age: { $in: [20, 25, 30] } });
+
+
+$regex: Regular expression matching.
+
+db.collection.find({ name: { $regex: "^A" } });
+-------------------------------------------------------------------------------------------------------------------------
+
+14. Common MongoDB Administrative Commands
+
+Show databases:
+
+show dbs;
+
+
+Switch database:
+
+use mydb;
+
+
+Show collections:
+
+show collections;
+
+
+Drop collection:
+
+db.collection.drop();
+
+
+Check server status:
+
+db.serverStatus();
+-------------------------------------------------------------------------------------------------------------------------
+
+15. MongoDB Aggregation Operators
+
+$sum: Sums values.
+
+db.collection.aggregate([{ $group: { _id: null, total: { $sum: "$age" } } }]);
+
+
+$avg: Averages values.
+
+$min, $max: Minimum and maximum values.
+-------------------------------------------------------------------------------------------------------------------------
+
+16. Data Modeling Strategies in MongoDB
+
+Embedded Model: Storing related data in a single document (1-to-1 relationships).
+
+Reference Model: Storing related data in separate documents (1-to-many or many-to-many relationships).
+
+Example of embedded model:
+
+{ _id: 1, name: "John", address: { city: "NY", zip: "10001" } }
+
+
+Example of reference model:
+
+{ _id: 1, name: "John" }
+{ _id: 1, user_id: 1, post: "Hello MongoDB!" }
+-------------------------------------------------------------------------------------------------------------------------
+
+17. MongoDB Data Validation
+
+Schema Validation: MongoDB allows schema validation on collections.
+
+db.createCollection("users", {
+    validator: {
+        $jsonSchema: {
+            bsonType: "object",
+            required: ["name", "age"],
+            properties: {
+                name: { bsonType: "string" },
+                age: { bsonType: "int" }
+            }
+        }
+    }
+});
+-------------------------------------------------------------------------------------------------------------------------
+
+18. MongoDB Best Practices
+
+Use indexes to improve query performance.
+
+Avoid storing large files in MongoDB. Use GridFS for large files.
+
+Limit document size to avoid performance bottlenecks.
+
+Use findOne and find efficiently to limit results.
+
+Keep data duplication low: Use references or embedded models appropriately.
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Extra MongoDB Topics
+1. MongoDB GridFS
+
+GridFS is a specification for storing and retrieving large files, such as images, videos, and other binary data, within MongoDB. 
+Instead of storing large files as a single document (which can be inefficient), GridFS splits the file into smaller chunks.
+
+Basic Operations:
+
+Upload a File:
+
+from pymongo import MongoClient
+import gridfs
+
+client = MongoClient("mongodb://localhost:27017")
+db = client.mydatabase
+fs = gridfs.GridFS(db)
+
+with open("largefile.txt", "rb") as f:
+    fs.put(f, filename="largefile.txt")
+
+
+Download a File:
+
+with open("downloaded_file.txt", "wb") as f:
+    file = fs.get_last_version(filename="largefile.txt")
+    f.write(file.read())
+-------------------------------------------------------------------------------------------------------------------------
+
+2. MongoDB Aggregation Pipeline Stages
+
+The aggregation framework provides a powerful set of stages to transform, filter, and manipulate data.
+
+$match: Filters documents that pass certain criteria (similar to find()).
+
+$group: Groups documents by a specified identifier.
+
+$project: Reshapes documents by adding, removing, or renaming fields.
+
+$sort: Sorts the documents.
+
+$lookup: Performs a left outer join with another collection.
+
+Example using $lookup:
+db.orders.aggregate([
+    {
+        $lookup: {
+            from: "products",
+            localField: "product_id",
+            foreignField: "_id",
+            as: "product_details"
+        }
+    }
+]);
+-------------------------------------------------------------------------------------------------------------------------
+
+3. Transactions in MongoDB
+
+MongoDB supports multi-document ACID transactions, which ensures that multiple operations 
+on multiple documents or collections are executed atomically.
+
+Basic Transaction:
+const session = client.startSession();
+
+session.startTransaction();
+
+try {
+    db.collection1.updateOne({ _id: 1 }, { $set: { status: "Processed" } }, { session });
+    db.collection2.updateOne({ _id: 1 }, { $set: { status: "Completed" } }, { session });
+    
+    session.commitTransaction();
+} catch (error) {
+    session.abortTransaction();
+    console.log("Transaction failed:", error);
+} finally {
+    session.endSession();
+}
+-------------------------------------------------------------------------------------------------------------------------
+
+4. Data Migration Tools
+
+MongoDB Atlas provides a Migration Tool for moving data between clusters.
+
+mongoimport and mongoexport: These tools allow you to import and export JSON or CSV data from MongoDB.
+
+Example:
+
+Import JSON Data:
+
+mongoimport --db mydb --collection mycollection --file data.json --jsonArray
+
+
+Export Data to JSON:
+
+mongoexport --db mydb --collection mycollection --out data.json
+-------------------------------------------------------------------------------------------------------------------------
+
+5. MongoDB WiredTiger Storage Engine
+
+The WiredTiger storage engine is the default storage engine in MongoDB, providing features like:
+
+Compression: Reduces disk usage.
+
+Concurrency: Better performance with multi-core systems due to its ability to handle concurrent reads and writes.
+
+Changing Storage Engine:
+db.createCollection("myCollection", { storageEngine: { wiredTiger: { configString: "block_compressor=zlib" } } });
+-------------------------------------------------------------------------------------------------------------------------
+
+6. MongoDB Data Modeling Patterns
+
+One-to-Many: Store related data in separate documents and use references.
+
+Example: Users and their posts.
+
+Many-to-Many: Use reference documents to represent relationships between multiple collections.
+
+Example: Students and Courses (many students can enroll in many courses).
+
+Example of One-to-Many:
+// Users collection
+{ "_id": 1, "name": "John" }
+
+// Posts collection
+{ "_id": 101, "user_id": 1, "content": "MongoDB is great!" }
+-------------------------------------------------------------------------------------------------------------------------
+
+7. MongoDB Performance Tuning
+
+To ensure optimal performance, MongoDB offers several tuning mechanisms:
+
+Indexing: Always create indexes on frequently queried fields.
+
+Profiling: Use MongoDB’s built-in profiler to log slow queries and optimize them.
+
+Connection Pooling: Efficiently manage the number of connections to the database.
+
+Enable Profiling:
+db.setProfilingLevel(2); // Logs all queries.
+
+Example of Indexing:
+db.collection.createIndex({ name: 1, age: -1 });
+-------------------------------------------------------------------------------------------------------------------------
+
+8. MongoDB Replica Set Elections
+
+In a replica set, when the primary node goes down, a new primary must be elected from the secondary nodes. 
+MongoDB handles this election process automatically. However, you can influence the election process by:
+
+Priority: The node with higher priority is more likely to be elected.
+
+Votes: Each member of the replica set has a vote.
+
+Example of Setting Priority:
+cfg = rs.conf();
+cfg.members[0].priority = 2; // Set higher priority for the first node
+rs.reconfig(cfg);
+-------------------------------------------------------------------------------------------------------------------------
+
+9. MongoDB Change Streams
+
+Change streams allow you to watch real-time changes in the MongoDB database without the need to continuously poll. 
+This is useful for building real-time applications, such as notifications, dashboards, and event-driven systems.
+
+Example using Change Streams:
+const changeStream = db.collection.watch();
+
+changeStream.on('change', (next) => {
+    console.log(next);
+});
+-------------------------------------------------------------------------------------------------------------------------
+
+10. MongoDB Atlas & Cloud
+
+MongoDB Atlas is MongoDB’s managed cloud database solution, offering:
+
+Auto-scaling: Automatically scales your database based on load.
+
+Performance Monitoring: Real-time performance metrics and diagnostics.
+
+Data Security: Built-in encryption and access controls.
+-------------------------------------------------------------------------------------------------------------------------
+
+11. MongoDB and Full-Text Search
+
+MongoDB provides a full-text search feature that can be enabled on specific fields of a collection.
+ This allows you to perform complex text search queries, including stemming, text indexing, and more.
+
+Creating a Text Index:
+db.collection.createIndex({ title: "text", description: "text" });
+
+Text Search Query:
+db.collection.find({ $text: { $search: "MongoDB" } });
+-------------------------------------------------------------------------------------------------------------------------
+
+12. MongoDB Schema Design Patterns
+
+There are several design patterns for organizing data in MongoDB:
+
+Normalization: Similar to relational database design, where data is kept in separate collections, and references are used.
+
+Denormalization: Data is stored in a single collection, often for performance reasons.
+
+CQRS (Command Query Responsibility Segregation): Separate the write and read models for better performance and scalability.
+-------------------------------------------------------------------------------------------------------------------------
+
+13. MongoDB MapReduce
+
+MapReduce is used for processing large datasets in parallel. MongoDB’s MapReduce function allows you to execute JavaScript functions for mapping and reducing tasks.
+
+Example:
+db.collection.mapReduce(
+    function() { emit(this.age, 1); },
+    function(key, values) { return Array.sum(values); },
+    { out: "age_count" }
+);