Nosql MongoDB Practice Exam — LearnCoachAssist

Question 1 Nosql MongoDB

What is a shard key?

The bucket pattern groups related data into fixed-size "buckets" within a single document. For time-series data, instead of one document per measurement, you store multiple measurements in an array within a single document (e.g., one document per hour). This reduces document count, improves read performance, and optimizes storage. mongosh (MongoDB Shell) is the modern command-line interface for interacting with MongoDB. It replaces the legacy mongo shell and offers syntax highlighting, intelligent autocomplete, and built-in help. It supports JavaScript and can run scripts: mongosh --eval "db.users.countDocuments()". A text index supports full-text search on string content. Create one with db.articles.createIndex({ content: "text" }). Query using $text and $search: db.articles.find({ $text: { $search: "mongodb tutorial" } }). Each collection can have at most one text index, but it can cover multiple fields. A shard key is an indexed field or compound fields that MongoDB uses to distribute documents across shards. Choosing a good shard key is critical — it should have high cardinality, low frequency, and distribute writes evenly. A poor shard key leads to hot spots where one shard handles most of the traffic.

Question 2 Nosql MongoDB

What is the maximum document size in MongoDB?

The maximum BSON document size in MongoDB is 16 megabytes. This limit ensures that a single document cannot use excessive memory or bandwidth. For storing files larger than 16MB, MongoDB provides GridFS, which splits files into smaller chunks stored as separate documents. The $match stage filters documents based on specified conditions, similar to a find() query. It should be placed early in the pipeline to reduce the number of documents processed by subsequent stages. Example: { $match: { status: "active" } }. A TTL (Time-To-Live) index automatically removes documents after a specified number of seconds. It is created on a field containing a Date value: db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 }). TTL indexes are useful for session data, logs, and temporary records. The $project stage reshapes documents by including, excluding, or computing new fields. Use 1 to include a field, 0 to exclude it, or an expression to create a computed field. Example: { $project: { fullName: { $concat: ["$first", " ", "$last"] }, _id: 0 } }.

Question 3 Nosql MongoDB

What does the $group stage do in the aggregation pipeline?

MongoDB is a NoSQL document-oriented database that stores data in flexible, JSON-like documents called BSON. It is designed for scalability and high performance, making it ideal for applications with rapidly evolving schemas and large volumes of unstructured or semi-structured data. MongoDB CRUD operations are:

Create: insertOne(), insertMany()
Read: find(), findOne()
Update: updateOne(), updateMany(), replaceOne()
Delete: deleteOne(), deleteMany()

The $group stage groups documents by a specified _id expression and applies accumulator operators like $sum, $avg, $min, $max, $push, and $first. Example: { $group: { _id: "$category", total: { $sum: "$price" } } }. The explain() method provides information about query execution plans. Use db.collection.find(query).explain("executionStats") to see details including whether an index was used (IXSCAN vs COLLSCAN), documents examined, and execution time. This is essential for query optimization.

Question 4 Nosql MongoDB

What does the $match stage do in the aggregation pipeline?

MongoDB provides query operators for filtering:

Comparison: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin
Logical: $and, $or, $not, $nor
Element: $exists, $type
Array: $all, $elemMatch, $size

The $match stage filters documents based on specified conditions, similar to a find() query. It should be placed early in the pipeline to reduce the number of documents processed by subsequent stages. Example: { $match: { status: "active" } }. A covered query is one that can be satisfied entirely using an index without examining any documents. This happens when both the query filter and the projection include only indexed fields. Covered queries are extremely fast because they avoid reading from disk. Use explain() to verify with totalDocsExamined: 0. A text index supports full-text search on string content. Create one with db.articles.createIndex({ content: "text" }). Query using $text and $search: db.articles.find({ $text: { $search: "mongodb tutorial" } }). Each collection can have at most one text index, but it can cover multiple fields.

Question 5 Nosql MongoDB

What is a replica set in MongoDB?

A MongoDB sharded cluster consists of:

Shards — store the actual data (each shard is a replica set)
Config servers — store metadata and configuration for the cluster
mongos — query routers that direct operations to the appropriate shards

A replica set is a group of MongoDB instances that maintain the same data set for high availability. It consists of a primary node (handles writes) and one or more secondary nodes (replicate data from the primary). If the primary fails, an automatic election promotes a secondary to primary. The $addToSet operator adds a value to an array only if it doesn't already exist, preventing duplicates. Example: db.users.updateOne({ _id: 1 }, { $addToSet: { roles: "admin" } }). Use $each with $addToSet to add multiple unique values at once. The $push operator appends a value to an array field. Example: db.posts.updateOne({ _id: 1 }, { $push: { tags: "mongodb" } }). Modifiers include $each (push multiple), $sort (sort array after push), $slice (limit array size), and $position (insert at index).

Question 6 Nosql MongoDB

What is mongosh?

Use db.collection.insertOne() for a single document or db.collection.insertMany() for multiple documents. Example: db.users.insertOne({ name: "Alice", age: 30 }). MongoDB automatically adds an _id field if not provided. mongosh (MongoDB Shell) is the modern command-line interface for interacting with MongoDB. It replaces the legacy mongo shell and offers syntax highlighting, intelligent autocomplete, and built-in help. It supports JavaScript and can run scripts: mongosh --eval "db.users.countDocuments()". An arbiter is a replica set member that participates in elections but does not hold data. It is used to break ties during primary election when you have an even number of data-bearing members. Arbiters are lightweight and require minimal resources, but should be used sparingly in production environments. Capped collections are fixed-size collections that automatically overwrite the oldest documents when the size limit is reached. They maintain insertion order and support high-throughput operations. Create with: db.createCollection("logs", { capped: true, size: 1048576, max: 1000 }). They are ideal for logs and cache-like use cases.

Question 7 Nosql MongoDB

What is MongoDB?

A shard key is an indexed field or compound fields that MongoDB uses to distribute documents across shards. Choosing a good shard key is critical — it should have high cardinality, low frequency, and distribute writes evenly. A poor shard key leads to hot spots where one shard handles most of the traffic. Wildcard indexes (introduced in v4.2) index all fields or a subset of fields with dynamic or unknown names. Create with db.data.createIndex({ "$**": 1 }) to index all fields, or db.data.createIndex({ "metadata.$**": 1 }) to index all subfields of metadata. They are useful for polymorphic schemas. MongoDB is a NoSQL document-oriented database that stores data in flexible, JSON-like documents called BSON. It is designed for scalability and high performance, making it ideal for applications with rapidly evolving schemas and large volumes of unstructured or semi-structured data. The $project stage reshapes documents by including, excluding, or computing new fields. Use 1 to include a field, 0 to exclude it, or an expression to create a computed field. Example: { $project: { fullName: { $concat: ["$first", " ", "$last"] }, _id: 0 } }.

Question 8 Nosql MongoDB

How do you use the explain() method?

mongosh (MongoDB Shell) is the modern command-line interface for interacting with MongoDB. It replaces the legacy mongo shell and offers syntax highlighting, intelligent autocomplete, and built-in help. It supports JavaScript and can run scripts: mongosh --eval "db.users.countDocuments()". The aggregation pipeline processes documents through a sequence of stages, each transforming the data. Common stages include $match (filter), $group (aggregate), $project (reshape), $sort, $limit, and $lookup (join). It is MongoDB's primary tool for complex data analysis and transformation. Write concern specifies the level of acknowledgment requested from MongoDB for write operations. Options include:

w: 0 — no acknowledgment
w: 1 — acknowledged by primary (default)
w: "majority" — acknowledged by majority of replica set members

Higher write concern increases durability but adds latency. The explain() method provides information about query execution plans. Use db.collection.find(query).explain("executionStats") to see details including whether an index was used (IXSCAN vs COLLSCAN), documents examined, and execution time. This is essential for query optimization.

Question 9 Nosql MongoDB

What is MongoDB Compass?

Embed when:

Data is always accessed together
One-to-few relationship
Data doesn't change frequently

Reference when:

Data is accessed independently
One-to-many or many-to-many relationship
Document size might exceed 16MB limit
Data is updated frequently

MongoDB Compass is the official GUI for MongoDB. It provides a visual interface for exploring data, building queries, viewing and optimizing query plans with explain(), managing indexes, and validating schema. It includes an aggregation pipeline builder that helps construct complex pipelines stage by stage. MongoDB provides query operators for filtering:

Comparison: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin
Logical: $and, $or, $not, $nor
Element: $exists, $type
Array: $all, $elemMatch, $size

The $group stage groups documents by a specified _id expression and applies accumulator operators like $sum, $avg, $min, $max, $push, and $first. Example: { $group: { _id: "$category", total: { $sum: "$price" } } }.

Question 10 Nosql MongoDB

What does the $lookup stage do?

Embed when:

Data is always accessed together
One-to-few relationship
Data doesn't change frequently

Reference when:

Data is accessed independently
One-to-many or many-to-many relationship
Document size might exceed 16MB limit
Data is updated frequently

The primary node records all write operations in its oplog (operations log). Secondary nodes continuously replicate by tailing the oplog and applying operations locally. Replication provides data redundancy, high availability through automatic failover, and the ability to distribute read operations across secondaries. The $lookup stage performs a left outer join with another collection, similar to a SQL JOIN. It requires from (target collection), localField, foreignField, and as (output array field). Example: { $lookup: { from: "orders", localField: "_id", foreignField: "userId", as: "userOrders" } }. The $addToSet operator adds a value to an array only if it doesn't already exist, preventing duplicates. Example: db.users.updateOne({ _id: 1 }, { $addToSet: { roles: "admin" } }). Use $each with $addToSet to add multiple unique values at once.

Question 11 Nosql MongoDB

How do you query documents in MongoDB?

Change streams allow applications to access real-time data changes without polling the oplog. They provide a subscription-based API: db.collection.watch() returns a cursor that emits events for inserts, updates, deletes, and replacements. Change streams are useful for triggering actions, syncing data, and building event-driven architectures. The attribute pattern restructures documents with many similar fields into an array of key-value pairs. Instead of { color: "red", size: "L", weight: 5 }, use { attributes: [{ k: "color", v: "red" }, { k: "size", v: "L" }] }. This allows indexing on { "attributes.k": 1, "attributes.v": 1 } to support queries on any attribute efficiently. Use db.collection.find(filter, projection) to query documents. Example: db.users.find({ age: { $gt: 25 } }) returns all users older than 25. Use findOne() to return only the first matching document. A replica set is a group of MongoDB instances that maintain the same data set for high availability. It consists of a primary node (handles writes) and one or more secondary nodes (replicate data from the primary). If the primary fails, an automatic election promotes a secondary to primary.

Question 12 Nosql MongoDB

What are wildcard indexes in MongoDB?

The maximum BSON document size in MongoDB is 16 megabytes. This limit ensures that a single document cannot use excessive memory or bandwidth. For storing files larger than 16MB, MongoDB provides GridFS, which splits files into smaller chunks stored as separate documents. Wildcard indexes (introduced in v4.2) index all fields or a subset of fields with dynamic or unknown names. Create with db.data.createIndex({ "$**": 1 }) to index all fields, or db.data.createIndex({ "metadata.$**": 1 }) to index all subfields of metadata. They are useful for polymorphic schemas. GridFS is a specification for storing and retrieving files that exceed the 16MB BSON document size limit. It stores files in two collections: fs.files (metadata) and fs.chunks (binary data in 255KB chunks). GridFS is useful for storing images, videos, audio, and other large files. The $addToSet operator adds a value to an array only if it doesn't already exist, preventing duplicates. Example: db.users.updateOne({ _id: 1 }, { $addToSet: { roles: "admin" } }). Use $each with $addToSet to add multiple unique values at once.

Question 13 Nosql MongoDB

What is write concern in MongoDB?

A TTL (Time-To-Live) index automatically removes documents after a specified number of seconds. It is created on a field containing a Date value: db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 }). TTL indexes are useful for session data, logs, and temporary records. Write concern specifies the level of acknowledgment requested from MongoDB for write operations. Options include:

w: 0 — no acknowledgment
w: 1 — acknowledged by primary (default)
w: "majority" — acknowledged by majority of replica set members

Higher write concern increases durability but adds latency. A text index supports full-text search on string content. Create one with db.articles.createIndex({ content: "text" }). Query using $text and $search: db.articles.find({ $text: { $search: "mongodb tutorial" } }). Each collection can have at most one text index, but it can cover multiple fields. Use db.collection.find(filter, projection) to query documents. Example: db.users.find({ age: { $gt: 25 } }) returns all users older than 25. Use findOne() to return only the first matching document.

Question 14 Nosql MongoDB

What is a text index in MongoDB?

The aggregation pipeline processes documents through a sequence of stages, each transforming the data. Common stages include $match (filter), $group (aggregate), $project (reshape), $sort, $limit, and $lookup (join). It is MongoDB's primary tool for complex data analysis and transformation. A TTL (Time-To-Live) index automatically removes documents after a specified number of seconds. It is created on a field containing a Date value: db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 }). TTL indexes are useful for session data, logs, and temporary records. The explain() method provides information about query execution plans. Use db.collection.find(query).explain("executionStats") to see details including whether an index was used (IXSCAN vs COLLSCAN), documents examined, and execution time. This is essential for query optimization. A text index supports full-text search on string content. Create one with db.articles.createIndex({ content: "text" }). Query using $text and $search: db.articles.find({ $text: { $search: "mongodb tutorial" } }). Each collection can have at most one text index, but it can cover multiple fields.

Question 15 Nosql MongoDB

What is the difference between embedded and referenced documents?

Embedded documents store related data within a single document (denormalized), ideal for one-to-few relationships and data read together. Referenced documents store relationships using ObjectId references (normalized), better for one-to-many or many-to-many relationships. Embedding provides faster reads; referencing provides data consistency and smaller document sizes. MongoDB provides query operators for filtering:

Comparison: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin
Logical: $and, $or, $not, $nor
Element: $exists, $type
Array: $all, $elemMatch, $size

GridFS is a specification for storing and retrieving files that exceed the 16MB BSON document size limit. It stores files in two collections: fs.files (metadata) and fs.chunks (binary data in 255KB chunks). GridFS is useful for storing images, videos, audio, and other large files. First create a text index: db.articles.createIndex({ title: "text", body: "text" }). Then search: db.articles.find({ $text: { $search: "mongodb performance" } }). Use $meta: "textScore" to sort by relevance. For advanced full-text search, consider Atlas Search which uses Apache Lucene under the hood.

Question 16 Nosql MongoDB

What are capped collections in MongoDB?

The aggregation pipeline processes documents through a sequence of stages, each transforming the data. Common stages include $match (filter), $group (aggregate), $project (reshape), $sort, $limit, and $lookup (join). It is MongoDB's primary tool for complex data analysis and transformation. An ObjectId is a 12-byte unique identifier automatically generated by MongoDB as the default _id field for each document. It consists of:

A 4-byte timestamp
A 5-byte random value
A 3-byte incrementing counter

ObjectIds are sortable by creation time. Capped collections are fixed-size collections that automatically overwrite the oldest documents when the size limit is reached. They maintain insertion order and support high-throughput operations. Create with: db.createCollection("logs", { capped: true, size: 1048576, max: 1000 }). They are ideal for logs and cache-like use cases. First create a text index: db.articles.createIndex({ title: "text", body: "text" }). Then search: db.articles.find({ $text: { $search: "mongodb performance" } }). Use $meta: "textScore" to sort by relevance. For advanced full-text search, consider Atlas Search which uses Apache Lucene under the hood.

Question 17 Nosql MongoDB

What is sharding in MongoDB?

The $addToSet operator adds a value to an array only if it doesn't already exist, preventing duplicates. Example: db.users.updateOne({ _id: 1 }, { $addToSet: { roles: "admin" } }). Use $each with $addToSet to add multiple unique values at once. Sharding is MongoDB's horizontal scaling strategy that distributes data across multiple servers called shards. Each shard holds a subset of the data based on a shard key. Sharding allows MongoDB to handle large data sets and high throughput by spreading the load across multiple machines. Embed when:

Data is always accessed together
One-to-few relationship
Data doesn't change frequently

Reference when:

Data is accessed independently
One-to-many or many-to-many relationship
Document size might exceed 16MB limit
Data is updated frequently

A covered query is one that can be satisfied entirely using an index without examining any documents. This happens when both the query filter and the projection include only indexed fields. Covered queries are extremely fast because they avoid reading from disk. Use explain() to verify with totalDocsExamined: 0.

Question 18 Nosql MongoDB

How do you update documents in MongoDB?

The $push operator appends a value to an array field. Example: db.posts.updateOne({ _id: 1 }, { $push: { tags: "mongodb" } }). Modifiers include $each (push multiple), $sort (sort array after push), $slice (limit array size), and $position (insert at index). Use db.collection.updateOne(filter, update) or updateMany(). Update operators include $set (set fields), $unset (remove fields), $inc (increment), $push (add to array), and $pull (remove from array). Example: db.users.updateOne({ name: "Alice" }, { $set: { age: 31 } }). The $addToSet operator adds a value to an array only if it doesn't already exist, preventing duplicates. Example: db.users.updateOne({ _id: 1 }, { $addToSet: { roles: "admin" } }). Use $each with $addToSet to add multiple unique values at once. The bucket pattern groups related data into fixed-size "buckets" within a single document. For time-series data, instead of one document per measurement, you store multiple measurements in an array within a single document (e.g., one document per hour). This reduces document count, improves read performance, and optimizes storage.

Question 19 Nosql MongoDB

When should you embed documents vs reference them?

Use db.collection.insertOne() for a single document or db.collection.insertMany() for multiple documents. Example: db.users.insertOne({ name: "Alice", age: 30 }). MongoDB automatically adds an _id field if not provided. First create a text index: db.articles.createIndex({ title: "text", body: "text" }). Then search: db.articles.find({ $text: { $search: "mongodb performance" } }). Use $meta: "textScore" to sort by relevance. For advanced full-text search, consider Atlas Search which uses Apache Lucene under the hood. An arbiter is a replica set member that participates in elections but does not hold data. It is used to break ties during primary election when you have an even number of data-bearing members. Arbiters are lightweight and require minimal resources, but should be used sparingly in production environments. Embed when:

Data is always accessed together
One-to-few relationship
Data doesn't change frequently

Reference when:

Data is accessed independently
One-to-many or many-to-many relationship
Document size might exceed 16MB limit
Data is updated frequently

Question 20 Nosql MongoDB

What is a covered query in MongoDB?

The bucket pattern groups related data into fixed-size "buckets" within a single document. For time-series data, instead of one document per measurement, you store multiple measurements in an array within a single document (e.g., one document per hour). This reduces document count, improves read performance, and optimizes storage. The explain() method provides information about query execution plans. Use db.collection.find(query).explain("executionStats") to see details including whether an index was used (IXSCAN vs COLLSCAN), documents examined, and execution time. This is essential for query optimization. A single field index is created on one field of a document. Example: db.users.createIndex({ email: 1 }) creates an ascending index on the email field. The value 1 means ascending, -1 means descending. MongoDB automatically creates a single field index on the _id field. A covered query is one that can be satisfied entirely using an index without examining any documents. This happens when both the query filter and the projection include only indexed fields. Covered queries are extremely fast because they avoid reading from disk. Use explain() to verify with totalDocsExamined: 0.

Question 21 Nosql MongoDB

What is an arbiter in a replica set?

First create a text index: db.articles.createIndex({ title: "text", body: "text" }). Then search: db.articles.find({ $text: { $search: "mongodb performance" } }). Use $meta: "textScore" to sort by relevance. For advanced full-text search, consider Atlas Search which uses Apache Lucene under the hood. MongoDB supports multi-document ACID transactions starting from version 4.0 (replica sets) and 4.2 (sharded clusters). Transactions ensure atomicity across multiple operations and collections. Use session.startTransaction(), perform operations, then session.commitTransaction() or session.abortTransaction(). An arbiter is a replica set member that participates in elections but does not hold data. It is used to break ties during primary election when you have an even number of data-bearing members. Arbiters are lightweight and require minimal resources, but should be used sparingly in production environments. mongosh (MongoDB Shell) is the modern command-line interface for interacting with MongoDB. It replaces the legacy mongo shell and offers syntax highlighting, intelligent autocomplete, and built-in help. It supports JavaScript and can run scripts: mongosh --eval "db.users.countDocuments()".

Question 22 Nosql MongoDB

What is the attribute pattern in MongoDB?

Use db.collection.insertOne() for a single document or db.collection.insertMany() for multiple documents. Example: db.users.insertOne({ name: "Alice", age: 30 }). MongoDB automatically adds an _id field if not provided. An ObjectId is a 12-byte unique identifier automatically generated by MongoDB as the default _id field for each document. It consists of:

A 4-byte timestamp
A 5-byte random value
A 3-byte incrementing counter

ObjectIds are sortable by creation time. The bucket pattern groups related data into fixed-size "buckets" within a single document. For time-series data, instead of one document per measurement, you store multiple measurements in an array within a single document (e.g., one document per hour). This reduces document count, improves read performance, and optimizes storage. The attribute pattern restructures documents with many similar fields into an array of key-value pairs. Instead of { color: "red", size: "L", weight: 5 }, use { attributes: [{ k: "color", v: "red" }, { k: "size", v: "L" }] }. This allows indexing on { "attributes.k": 1, "attributes.v": 1 } to support queries on any attribute efficiently.

Question 23 Nosql MongoDB

What is the aggregation pipeline in MongoDB?

The aggregation pipeline processes documents through a sequence of stages, each transforming the data. Common stages include $match (filter), $group (aggregate), $project (reshape), $sort, $limit, and $lookup (join). It is MongoDB's primary tool for complex data analysis and transformation. A shard key is an indexed field or compound fields that MongoDB uses to distribute documents across shards. Choosing a good shard key is critical — it should have high cardinality, low frequency, and distribute writes evenly. A poor shard key leads to hot spots where one shard handles most of the traffic. Use db.collection.find(filter, projection) to query documents. Example: db.users.find({ age: { $gt: 25 } }) returns all users older than 25. Use findOne() to return only the first matching document. The document model stores data as documents, which are rich data structures similar to JSON objects. Each document can contain nested fields, arrays, and sub-documents, allowing related data to be stored together rather than spread across multiple tables as in relational databases.

Question 24 Nosql MongoDB

What is a compound index in MongoDB?

MongoDB Atlas is the fully managed cloud database service by MongoDB, available on AWS, Azure, and Google Cloud. It provides automated provisioning, scaling, backup, monitoring, and security features. Atlas includes a free tier (M0) for development and offers features like Atlas Search, Data Lake, and Charts. Embedded documents store related data within a single document (denormalized), ideal for one-to-few relationships and data read together. Referenced documents store relationships using ObjectId references (normalized), better for one-to-many or many-to-many relationships. Embedding provides faster reads; referencing provides data consistency and smaller document sizes. A compound index includes multiple fields in a single index. Example: db.orders.createIndex({ userId: 1, createdAt: -1 }). The order of fields matters — compound indexes support queries that match a prefix of the index fields. They follow the ESR rule: Equality, Sort, Range for optimal field ordering. Key differences:

Data model: MongoDB uses documents; SQL uses tables with rows and columns
Schema: MongoDB is schema-flexible; SQL enforces a fixed schema
Joins: MongoDB uses $lookup and embedding; SQL uses JOIN
Scaling: MongoDB scales horizontally via sharding; SQL typically scales vertically
Transactions: Both support ACID, but SQL has more mature transaction support

Question 25 Nosql MongoDB

What is the polymorphic pattern in MongoDB?

An arbiter is a replica set member that participates in elections but does not hold data. It is used to break ties during primary election when you have an even number of data-bearing members. Arbiters are lightweight and require minimal resources, but should be used sparingly in production environments. A text index supports full-text search on string content. Create one with db.articles.createIndex({ content: "text" }). Query using $text and $search: db.articles.find({ $text: { $search: "mongodb tutorial" } }). Each collection can have at most one text index, but it can cover multiple fields. MongoDB Compass is the official GUI for MongoDB. It provides a visual interface for exploring data, building queries, viewing and optimizing query plans with explain(), managing indexes, and validating schema. It includes an aggregation pipeline builder that helps construct complex pipelines stage by stage. The polymorphic pattern stores documents with different shapes in the same collection, using a discriminator field (e.g., type) to distinguish them. For example, a products collection might contain both { type: "book", author: "..." } and { type: "movie", director: "..." }. This leverages MongoDB's flexible schema.

Question 26 Nosql MongoDB

What is MongoDB Atlas?

Key differences:

Data model: MongoDB uses documents; SQL uses tables with rows and columns
Schema: MongoDB is schema-flexible; SQL enforces a fixed schema
Joins: MongoDB uses $lookup and embedding; SQL uses JOIN
Scaling: MongoDB scales horizontally via sharding; SQL typically scales vertically
Transactions: Both support ACID, but SQL has more mature transaction support

An ObjectId is a 12-byte unique identifier automatically generated by MongoDB as the default _id field for each document. It consists of:

A 4-byte timestamp
A 5-byte random value
A 3-byte incrementing counter

ObjectIds are sortable by creation time. MongoDB Atlas is the fully managed cloud database service by MongoDB, available on AWS, Azure, and Google Cloud. It provides automated provisioning, scaling, backup, monitoring, and security features. Atlas includes a free tier (M0) for development and offers features like Atlas Search, Data Lake, and Charts. A MongoDB sharded cluster consists of:

Shards — store the actual data (each shard is a replica set)
Config servers — store metadata and configuration for the cluster
mongos — query routers that direct operations to the appropriate shards

Question 27 Nosql MongoDB

How do you insert a document in MongoDB?

Embedded documents store related data within a single document (denormalized), ideal for one-to-few relationships and data read together. Referenced documents store relationships using ObjectId references (normalized), better for one-to-many or many-to-many relationships. Embedding provides faster reads; referencing provides data consistency and smaller document sizes. MongoDB CRUD operations are:

Create: insertOne(), insertMany()
Read: find(), findOne()
Update: updateOne(), updateMany(), replaceOne()
Delete: deleteOne(), deleteMany()

Use db.collection.insertOne() for a single document or db.collection.insertMany() for multiple documents. Example: db.users.insertOne({ name: "Alice", age: 30 }). MongoDB automatically adds an _id field if not provided. MongoDB is a NoSQL document-oriented database that stores data in flexible, JSON-like documents called BSON. It is designed for scalability and high performance, making it ideal for applications with rapidly evolving schemas and large volumes of unstructured or semi-structured data.

Question 28 Nosql MongoDB

What does the $project stage do?

MongoDB supports multi-document ACID transactions starting from version 4.0 (replica sets) and 4.2 (sharded clusters). Transactions ensure atomicity across multiple operations and collections. Use session.startTransaction(), perform operations, then session.commitTransaction() or session.abortTransaction(). Indexing improves query performance by creating efficient data structures (B-tree) that allow MongoDB to locate documents without scanning the entire collection. Without indexes, MongoDB performs a collection scan. Indexes consume additional storage and memory, and slow down write operations, so they should be created strategically. The $project stage reshapes documents by including, excluding, or computing new fields. Use 1 to include a field, 0 to exclude it, or an expression to create a computed field. Example: { $project: { fullName: { $concat: ["$first", " ", "$last"] }, _id: 0 } }. Use db.collection.insertOne() for a single document or db.collection.insertMany() for multiple documents. Example: db.users.insertOne({ name: "Alice", age: 30 }). MongoDB automatically adds an _id field if not provided.

Question 29 Nosql MongoDB

How do you perform a text search in MongoDB?

First create a text index: db.articles.createIndex({ title: "text", body: "text" }). Then search: db.articles.find({ $text: { $search: "mongodb performance" } }). Use $meta: "textScore" to sort by relevance. For advanced full-text search, consider Atlas Search which uses Apache Lucene under the hood. MongoDB is a NoSQL document-oriented database that stores data in flexible, JSON-like documents called BSON. It is designed for scalability and high performance, making it ideal for applications with rapidly evolving schemas and large volumes of unstructured or semi-structured data. Capped collections are fixed-size collections that automatically overwrite the oldest documents when the size limit is reached. They maintain insertion order and support high-throughput operations. Create with: db.createCollection("logs", { capped: true, size: 1048576, max: 1000 }). They are ideal for logs and cache-like use cases. The $push operator appends a value to an array field. Example: db.posts.updateOne({ _id: 1 }, { $push: { tags: "mongodb" } }). Modifiers include $each (push multiple), $sort (sort array after push), $slice (limit array size), and $position (insert at index).

Question 30 Nosql MongoDB

What is a TTL index in MongoDB?

BSON (Binary JSON) is the binary-encoded serialization format MongoDB uses to store documents and make remote procedure calls. It extends JSON with additional data types such as Date, ObjectId, int, long, double, and binary, enabling efficient storage and traversal. The $project stage reshapes documents by including, excluding, or computing new fields. Use 1 to include a field, 0 to exclude it, or an expression to create a computed field. Example: { $project: { fullName: { $concat: ["$first", " ", "$last"] }, _id: 0 } }. A TTL (Time-To-Live) index automatically removes documents after a specified number of seconds. It is created on a field containing a Date value: db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 }). TTL indexes are useful for session data, logs, and temporary records. Capped collections are fixed-size collections that automatically overwrite the oldest documents when the size limit is reached. They maintain insertion order and support high-throughput operations. Create with: db.createCollection("logs", { capped: true, size: 1048576, max: 1000 }). They are ideal for logs and cache-like use cases.

Question 31 Nosql MongoDB

What is the bucket pattern in MongoDB schema design?

GridFS is a specification for storing and retrieving files that exceed the 16MB BSON document size limit. It stores files in two collections: fs.files (metadata) and fs.chunks (binary data in 255KB chunks). GridFS is useful for storing images, videos, audio, and other large files. Sharding is MongoDB's horizontal scaling strategy that distributes data across multiple servers called shards. Each shard holds a subset of the data based on a shard key. Sharding allows MongoDB to handle large data sets and high throughput by spreading the load across multiple machines. A compound index includes multiple fields in a single index. Example: db.orders.createIndex({ userId: 1, createdAt: -1 }). The order of fields matters — compound indexes support queries that match a prefix of the index fields. They follow the ESR rule: Equality, Sort, Range for optimal field ordering. The bucket pattern groups related data into fixed-size "buckets" within a single document. For time-series data, instead of one document per measurement, you store multiple measurements in an array within a single document (e.g., one document per hour). This reduces document count, improves read performance, and optimizes storage.

Question 32 Nosql MongoDB

What is the document model in MongoDB?

The explain() method provides information about query execution plans. Use db.collection.find(query).explain("executionStats") to see details including whether an index was used (IXSCAN vs COLLSCAN), documents examined, and execution time. This is essential for query optimization. A shard key is an indexed field or compound fields that MongoDB uses to distribute documents across shards. Choosing a good shard key is critical — it should have high cardinality, low frequency, and distribute writes evenly. A poor shard key leads to hot spots where one shard handles most of the traffic. The aggregation pipeline processes documents through a sequence of stages, each transforming the data. Common stages include $match (filter), $group (aggregate), $project (reshape), $sort, $limit, and $lookup (join). It is MongoDB's primary tool for complex data analysis and transformation. The document model stores data as documents, which are rich data structures similar to JSON objects. Each document can contain nested fields, arrays, and sub-documents, allowing related data to be stored together rather than spread across multiple tables as in relational databases.

Question 33 Nosql MongoDB

What are MongoDB transactions?

MongoDB Compass is the official GUI for MongoDB. It provides a visual interface for exploring data, building queries, viewing and optimizing query plans with explain(), managing indexes, and validating schema. It includes an aggregation pipeline builder that helps construct complex pipelines stage by stage. MongoDB supports multi-document ACID transactions starting from version 4.0 (replica sets) and 4.2 (sharded clusters). Transactions ensure atomicity across multiple operations and collections. Use session.startTransaction(), perform operations, then session.commitTransaction() or session.abortTransaction(). The $unwind stage deconstructs an array field, creating a separate document for each element. For example, if a document has tags: ["a", "b", "c"], { $unwind: "$tags" } produces three documents, each with a single tag value. Use preserveNullAndEmptyArrays: true to keep documents with missing or empty arrays. A replica set is a group of MongoDB instances that maintain the same data set for high availability. It consists of a primary node (handles writes) and one or more secondary nodes (replicate data from the primary). If the primary fails, an automatic election promotes a secondary to primary.

Question 34 Nosql MongoDB

What is an ObjectId in MongoDB?

An ObjectId is a 12-byte unique identifier automatically generated by MongoDB as the default _id field for each document. It consists of:

A 4-byte timestamp
A 5-byte random value
A 3-byte incrementing counter

ObjectIds are sortable by creation time. The aggregation pipeline processes documents through a sequence of stages, each transforming the data. Common stages include $match (filter), $group (aggregate), $project (reshape), $sort, $limit, and $lookup (join). It is MongoDB's primary tool for complex data analysis and transformation. A shard key is an indexed field or compound fields that MongoDB uses to distribute documents across shards. Choosing a good shard key is critical — it should have high cardinality, low frequency, and distribute writes evenly. A poor shard key leads to hot spots where one shard handles most of the traffic. Embed when:

Data is always accessed together
One-to-few relationship
Data doesn't change frequently

Reference when:

Data is accessed independently
One-to-many or many-to-many relationship
Document size might exceed 16MB limit
Data is updated frequently

Question 35 Nosql MongoDB

What are the basic CRUD operations in MongoDB?

The $addToSet operator adds a value to an array only if it doesn't already exist, preventing duplicates. Example: db.users.updateOne({ _id: 1 }, { $addToSet: { roles: "admin" } }). Use $each with $addToSet to add multiple unique values at once. Capped collections are fixed-size collections that automatically overwrite the oldest documents when the size limit is reached. They maintain insertion order and support high-throughput operations. Create with: db.createCollection("logs", { capped: true, size: 1048576, max: 1000 }). They are ideal for logs and cache-like use cases. A compound index includes multiple fields in a single index. Example: db.orders.createIndex({ userId: 1, createdAt: -1 }). The order of fields matters — compound indexes support queries that match a prefix of the index fields. They follow the ESR rule: Equality, Sort, Range for optimal field ordering. MongoDB CRUD operations are:

Create: insertOne(), insertMany()
Read: find(), findOne()
Update: updateOne(), updateMany(), replaceOne()
Delete: deleteOne(), deleteMany()

Question 36 Nosql MongoDB

What is a single field index in MongoDB?

MongoDB Atlas is the fully managed cloud database service by MongoDB, available on AWS, Azure, and Google Cloud. It provides automated provisioning, scaling, backup, monitoring, and security features. Atlas includes a free tier (M0) for development and offers features like Atlas Search, Data Lake, and Charts. BSON (Binary JSON) is the binary-encoded serialization format MongoDB uses to store documents and make remote procedure calls. It extends JSON with additional data types such as Date, ObjectId, int, long, double, and binary, enabling efficient storage and traversal. mongosh (MongoDB Shell) is the modern command-line interface for interacting with MongoDB. It replaces the legacy mongo shell and offers syntax highlighting, intelligent autocomplete, and built-in help. It supports JavaScript and can run scripts: mongosh --eval "db.users.countDocuments()". A single field index is created on one field of a document. Example: db.users.createIndex({ email: 1 }) creates an ascending index on the email field. The value 1 means ascending, -1 means descending. MongoDB automatically creates a single field index on the _id field.

Question 37 Nosql MongoDB

What does the $unwind stage do?

The $unwind stage deconstructs an array field, creating a separate document for each element. For example, if a document has tags: ["a", "b", "c"], { $unwind: "$tags" } produces three documents, each with a single tag value. Use preserveNullAndEmptyArrays: true to keep documents with missing or empty arrays. Embed when:

Data is always accessed together
One-to-few relationship
Data doesn't change frequently

Reference when:

Data is accessed independently
One-to-many or many-to-many relationship
Document size might exceed 16MB limit
Data is updated frequently

The $addToSet operator adds a value to an array only if it doesn't already exist, preventing duplicates. Example: db.users.updateOne({ _id: 1 }, { $addToSet: { roles: "admin" } }). Use $each with $addToSet to add multiple unique values at once. A MongoDB sharded cluster consists of:

Shards — store the actual data (each shard is a replica set)
Config servers — store metadata and configuration for the cluster
mongos — query routers that direct operations to the appropriate shards

Question 38 Nosql MongoDB

What is the $push operator in MongoDB?

The $push operator appends a value to an array field. Example: db.posts.updateOne({ _id: 1 }, { $push: { tags: "mongodb" } }). Modifiers include $each (push multiple), $sort (sort array after push), $slice (limit array size), and $position (insert at index). MongoDB provides query operators for filtering:

Comparison: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin
Logical: $and, $or, $not, $nor
Element: $exists, $type
Array: $all, $elemMatch, $size

A compound index includes multiple fields in a single index. Example: db.orders.createIndex({ userId: 1, createdAt: -1 }). The order of fields matters — compound indexes support queries that match a prefix of the index fields. They follow the ESR rule: Equality, Sort, Range for optimal field ordering. Use db.collection.find(filter, projection) to query documents. Example: db.users.find({ age: { $gt: 25 } }) returns all users older than 25. Use findOne() to return only the first matching document.

Question 39 Nosql MongoDB

What are the components of a sharded cluster?

MongoDB provides query operators for filtering:

Comparison: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin
Logical: $and, $or, $not, $nor
Element: $exists, $type
Array: $all, $elemMatch, $size

A MongoDB sharded cluster consists of:

Shards — store the actual data (each shard is a replica set)
Config servers — store metadata and configuration for the cluster
mongos — query routers that direct operations to the appropriate shards

A replica set is a group of MongoDB instances that maintain the same data set for high availability. It consists of a primary node (handles writes) and one or more secondary nodes (replicate data from the primary). If the primary fails, an automatic election promotes a secondary to primary. MongoDB Compass is the official GUI for MongoDB. It provides a visual interface for exploring data, building queries, viewing and optimizing query plans with explain(), managing indexes, and validating schema. It includes an aggregation pipeline builder that helps construct complex pipelines stage by stage.

Question 40 Nosql MongoDB

What is GridFS in MongoDB?

The $group stage groups documents by a specified _id expression and applies accumulator operators like $sum, $avg, $min, $max, $push, and $first. Example: { $group: { _id: "$category", total: { $sum: "$price" } } }. MongoDB CRUD operations are:

Create: insertOne(), insertMany()
Read: find(), findOne()
Update: updateOne(), updateMany(), replaceOne()
Delete: deleteOne(), deleteMany()

The attribute pattern restructures documents with many similar fields into an array of key-value pairs. Instead of { color: "red", size: "L", weight: 5 }, use { attributes: [{ k: "color", v: "red" }, { k: "size", v: "L" }] }. This allows indexing on { "attributes.k": 1, "attributes.v": 1 } to support queries on any attribute efficiently. GridFS is a specification for storing and retrieving files that exceed the 16MB BSON document size limit. It stores files in two collections: fs.files (metadata) and fs.chunks (binary data in 255KB chunks). GridFS is useful for storing images, videos, audio, and other large files.

Question 41 Nosql MongoDB

What is indexing in MongoDB?

GridFS is a specification for storing and retrieving files that exceed the 16MB BSON document size limit. It stores files in two collections: fs.files (metadata) and fs.chunks (binary data in 255KB chunks). GridFS is useful for storing images, videos, audio, and other large files. Indexing improves query performance by creating efficient data structures (B-tree) that allow MongoDB to locate documents without scanning the entire collection. Without indexes, MongoDB performs a collection scan. Indexes consume additional storage and memory, and slow down write operations, so they should be created strategically. Use db.collection.updateOne(filter, update) or updateMany(). Update operators include $set (set fields), $unset (remove fields), $inc (increment), $push (add to array), and $pull (remove from array). Example: db.users.updateOne({ name: "Alice" }, { $set: { age: 31 } }). A replica set is a group of MongoDB instances that maintain the same data set for high availability. It consists of a primary node (handles writes) and one or more secondary nodes (replicate data from the primary). If the primary fails, an automatic election promotes a secondary to primary.

Question 42 Nosql MongoDB

What is a multikey index in MongoDB?

Key differences:

Data model: MongoDB uses documents; SQL uses tables with rows and columns
Schema: MongoDB is schema-flexible; SQL enforces a fixed schema
Joins: MongoDB uses $lookup and embedding; SQL uses JOIN
Scaling: MongoDB scales horizontally via sharding; SQL typically scales vertically
Transactions: Both support ACID, but SQL has more mature transaction support

Embedded documents store related data within a single document (denormalized), ideal for one-to-few relationships and data read together. Referenced documents store relationships using ObjectId references (normalized), better for one-to-many or many-to-many relationships. Embedding provides faster reads; referencing provides data consistency and smaller document sizes. A single field index is created on one field of a document. Example: db.users.createIndex({ email: 1 }) creates an ascending index on the email field. The value 1 means ascending, -1 means descending. MongoDB automatically creates a single field index on the _id field. A multikey index is automatically created when you index a field that holds an array. MongoDB creates separate index entries for each element of the array. For example, indexing { tags: 1 } on a document with tags: ["A", "B"] creates entries for both values. A compound index cannot include more than one array field.

Question 43 Nosql MongoDB

What is read preference in MongoDB?

Key differences:

Data model: MongoDB uses documents; SQL uses tables with rows and columns
Schema: MongoDB is schema-flexible; SQL enforces a fixed schema
Joins: MongoDB uses $lookup and embedding; SQL uses JOIN
Scaling: MongoDB scales horizontally via sharding; SQL typically scales vertically
Transactions: Both support ACID, but SQL has more mature transaction support

The $group stage groups documents by a specified _id expression and applies accumulator operators like $sum, $avg, $min, $max, $push, and $first. Example: { $group: { _id: "$category", total: { $sum: "$price" } } }. Read preference determines which replica set members receive read operations. Options include:

primary — reads from primary only (default)
primaryPreferred — primary, fallback to secondary
secondary — reads from secondaries only
secondaryPreferred — secondary, fallback to primary
nearest — lowest latency member

An arbiter is a replica set member that participates in elections but does not hold data. It is used to break ties during primary election when you have an even number of data-bearing members. Arbiters are lightweight and require minimal resources, but should be used sparingly in production environments.

Question 44 Nosql MongoDB

What is BSON?

BSON (Binary JSON) is the binary-encoded serialization format MongoDB uses to store documents and make remote procedure calls. It extends JSON with additional data types such as Date, ObjectId, int, long, double, and binary, enabling efficient storage and traversal. A shard key is an indexed field or compound fields that MongoDB uses to distribute documents across shards. Choosing a good shard key is critical — it should have high cardinality, low frequency, and distribute writes evenly. A poor shard key leads to hot spots where one shard handles most of the traffic. Wildcard indexes (introduced in v4.2) index all fields or a subset of fields with dynamic or unknown names. Create with db.data.createIndex({ "$**": 1 }) to index all fields, or db.data.createIndex({ "metadata.$**": 1 }) to index all subfields of metadata. They are useful for polymorphic schemas. A replica set is a group of MongoDB instances that maintain the same data set for high availability. It consists of a primary node (handles writes) and one or more secondary nodes (replicate data from the primary). If the primary fails, an automatic election promotes a secondary to primary.

Question 45 Nosql MongoDB

How does replication work in MongoDB?

A TTL (Time-To-Live) index automatically removes documents after a specified number of seconds. It is created on a field containing a Date value: db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 }). TTL indexes are useful for session data, logs, and temporary records. Use db.collection.updateOne(filter, update) or updateMany(). Update operators include $set (set fields), $unset (remove fields), $inc (increment), $push (add to array), and $pull (remove from array). Example: db.users.updateOne({ name: "Alice" }, { $set: { age: 31 } }). Use db.collection.find(filter, projection) to query documents. Example: db.users.find({ age: { $gt: 25 } }) returns all users older than 25. Use findOne() to return only the first matching document. The primary node records all write operations in its oplog (operations log). Secondary nodes continuously replicate by tailing the oplog and applying operations locally. Replication provides data redundancy, high availability through automatic failover, and the ability to distribute read operations across secondaries.

Question 46 Nosql MongoDB

What are change streams in MongoDB?

The bucket pattern groups related data into fixed-size "buckets" within a single document. For time-series data, instead of one document per measurement, you store multiple measurements in an array within a single document (e.g., one document per hour). This reduces document count, improves read performance, and optimizes storage. BSON (Binary JSON) is the binary-encoded serialization format MongoDB uses to store documents and make remote procedure calls. It extends JSON with additional data types such as Date, ObjectId, int, long, double, and binary, enabling efficient storage and traversal. Change streams allow applications to access real-time data changes without polling the oplog. They provide a subscription-based API: db.collection.watch() returns a cursor that emits events for inserts, updates, deletes, and replacements. Change streams are useful for triggering actions, syncing data, and building event-driven architectures. Use db.collection.find(filter, projection) to query documents. Example: db.users.find({ age: { $gt: 25 } }) returns all users older than 25. Use findOne() to return only the first matching document.

Question 47 Nosql MongoDB

What are MongoDB query operators?

A single field index is created on one field of a document. Example: db.users.createIndex({ email: 1 }) creates an ascending index on the email field. The value 1 means ascending, -1 means descending. MongoDB automatically creates a single field index on the _id field. Key differences:

Data model: MongoDB uses documents; SQL uses tables with rows and columns
Schema: MongoDB is schema-flexible; SQL enforces a fixed schema
Joins: MongoDB uses $lookup and embedding; SQL uses JOIN
Scaling: MongoDB scales horizontally via sharding; SQL typically scales vertically
Transactions: Both support ACID, but SQL has more mature transaction support

MongoDB provides query operators for filtering:

Comparison: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin
Logical: $and, $or, $not, $nor
Element: $exists, $type
Array: $all, $elemMatch, $size

BSON (Binary JSON) is the binary-encoded serialization format MongoDB uses to store documents and make remote procedure calls. It extends JSON with additional data types such as Date, ObjectId, int, long, double, and binary, enabling efficient storage and traversal.

Question 48 Nosql MongoDB

What is the $set operator in MongoDB?

First create a text index: db.articles.createIndex({ title: "text", body: "text" }). Then search: db.articles.find({ $text: { $search: "mongodb performance" } }). Use $meta: "textScore" to sort by relevance. For advanced full-text search, consider Atlas Search which uses Apache Lucene under the hood. The $push operator appends a value to an array field. Example: db.posts.updateOne({ _id: 1 }, { $push: { tags: "mongodb" } }). Modifiers include $each (push multiple), $sort (sort array after push), $slice (limit array size), and $position (insert at index). The $set operator replaces the value of a field or creates it if it doesn't exist. Example: db.users.updateOne({ _id: 1 }, { $set: { name: "Bob", "address.city": "NYC" } }). It can update top-level fields, nested fields using dot notation, and array elements by index. The bucket pattern groups related data into fixed-size "buckets" within a single document. For time-series data, instead of one document per measurement, you store multiple measurements in an array within a single document (e.g., one document per hour). This reduces document count, improves read performance, and optimizes storage.

Question 49 Nosql MongoDB

How does MongoDB compare to SQL databases?

Key differences:

Data model: MongoDB uses documents; SQL uses tables with rows and columns
Schema: MongoDB is schema-flexible; SQL enforces a fixed schema
Joins: MongoDB uses $lookup and embedding; SQL uses JOIN
Scaling: MongoDB scales horizontally via sharding; SQL typically scales vertically
Transactions: Both support ACID, but SQL has more mature transaction support

Use db.collection.updateOne(filter, update) or updateMany(). Update operators include $set (set fields), $unset (remove fields), $inc (increment), $push (add to array), and $pull (remove from array). Example: db.users.updateOne({ name: "Alice" }, { $set: { age: 31 } }). MongoDB Compass is the official GUI for MongoDB. It provides a visual interface for exploring data, building queries, viewing and optimizing query plans with explain(), managing indexes, and validating schema. It includes an aggregation pipeline builder that helps construct complex pipelines stage by stage. The $lookup stage performs a left outer join with another collection, similar to a SQL JOIN. It requires from (target collection), localField, foreignField, and as (output array field). Example: { $lookup: { from: "orders", localField: "_id", foreignField: "userId", as: "userOrders" } }.

Question 50 Nosql MongoDB

What is the $addToSet operator?

Embed when:

Data is always accessed together
One-to-few relationship
Data doesn't change frequently

Reference when:

Data is accessed independently
One-to-many or many-to-many relationship
Document size might exceed 16MB limit
Data is updated frequently

The $addToSet operator adds a value to an array only if it doesn't already exist, preventing duplicates. Example: db.users.updateOne({ _id: 1 }, { $addToSet: { roles: "admin" } }). Use $each with $addToSet to add multiple unique values at once. A single field index is created on one field of a document. Example: db.users.createIndex({ email: 1 }) creates an ascending index on the email field. The value 1 means ascending, -1 means descending. MongoDB automatically creates a single field index on the _id field. Read preference determines which replica set members receive read operations. Options include:

primary — reads from primary only (default)
primaryPreferred — primary, fallback to secondary
secondary — reads from secondaries only
secondaryPreferred — secondary, fallback to primary
nearest — lowest latency member