MongoDB Interview Master

MongoDB is an open-source, document-oriented NoSQL database program. Instead of using tables and rows as in traditional relational databases, MongoDB uses JSON-...

A document is the basic unit of data in MongoDB, analogous to a row in an RDBMS. Documents are composed of field-and-value pairs and are stored in BSON (Binary ...

{
  "name": "John Doe",
  "age": 30,
  "interests": ["coding", "reading"]
}

A collection is a grouping of MongoDB documents. It is equivalent to a table in a relational database. Collections do not enforce a strict schema, although sche...

BSON stands for **Binary JSON**. It is a binary-encoded serialization of JSON-like documents. BSON extends the JSON model to provide additional data types (like...

Key advantages include: 1. **Flexible Schema**: Documents in a collection can have different fields. 2. **Scalability**: Seamless horizontal scaling via shardin...

The `_id` field is a unique identifier required for every document in a collection. If you don't provide one, MongoDB automatically generates an `ObjectId` for ...

An ObjectId is a 12-byte BSON type that is unique within a collection. It consists of: - A 4-byte timestamp (seconds since Unix epoch). - A 5-byte random value....

In the MongoDB Shell, you use the `use` command. MongoDB will not actually create the database until you insert data into it.

use interview_db

You use `insertOne()` for a single document or `insertMany()` for multiple documents.

db.users.insertOne({ name: "Alice", age: 25 });

You use the `find()` method. To make the output readable, you can append `.pretty()` (in older shells) or just run it.

db.users.find();

- **RDBMS**: Structured (Tables/Rows), uses SQL, strict schema, joins are common, vertically scalable. - **MongoDB**: Unstructured (Collections/Documents), uses...

A namespace is the concatenation of the database name and the collection name (e.g., `dbName.collectionName`). Together they uniquely identify a collection.

You use `updateOne()`, `updateMany()`, or `replaceOne()`. Use the `$set` operator to update specific fields.

db.users.updateOne(
  { name: "Alice" }, 
  { $set: { age: 26 } }
);

You use `deleteOne()` or `deleteMany()`.

db.users.deleteOne({ name: "Alice" });

The `$set` operator replaces the value of a field with the specified value. If the field does not exist, `$set` adds a new field with the specified value.

- **find()**: Returns a cursor to all documents that match the query criteria. - **findOne()**: Returns only the first document that matches the query criteria.

You use the `.limit()` method on the cursor.

db.users.find().limit(5);

You use the `.sort()` method. Use **1** for ascending and **-1** for descending.

db.users.find().sort({ age: 1 }); // Youngest first

Projection is the process of selecting only the necessary fields from a document rather than the entire document. You pass a second argument to `find()`.

db.users.find({}, { name: 1, _id: 0 }); // Show only name

The `$in` operator selects the documents where the value of a field equals any value in the specified array.

db.users.find({ age: { $in: [20, 25, 30] } });

You use `countDocuments()` or `estimatedDocumentCount()`.

db.users.countDocuments({ age: { $gt: 18 } });

Indexes are special data structures that store a small portion of the collection's data set in a form that is easy to traverse. They improve the efficiency of s...

GridFS is a specification for storing and retrieving files that exceed the BSON-document size limit of 16 MB. It divides a file into chunks and stores each chun...

The default port for MongoDB is **27017**.

You use the `show dbs` command (or `show databases`).

show dbs

Use the `countDocuments()` method for an accurate count or `estimatedDocumentCount()` for a faster but potentially less accurate estimate.

db.users.countDocuments({ status: "active" });

The aggregation pipeline is a framework for data transformation. Documents enter a multi-stage pipeline that transforms them into aggregated results. Common sta...

db.orders.aggregate([
  { $match: { status: "A" } },
  { $group: { _id: "$cust_id", total: { $sum: "$amount" } } }
]);

The `$match` stage filters the documents based on specific criteria. It is recommended to use `$match` early in the pipeline to reduce the number of documents p...

The `$group` stage groups input documents by a specified identifier expression and applies accumulator expressions (like `$sum`, `$avg`, `$push`) to each group.

{ $group: { _id: "$category", totalStock: { $sum: "$stock" } } }

- **Embedding**: Storing related data in a single document. Good for high-read performance and 'one-to-few' relationships. - **Referencing**: Storing references...

A TTL index is a special index that automatically removes documents from a collection after a certain amount of time. It is useful for data like machine-generat...

db.logs.createIndex({ "createdAt": 1 }, { expireAfterSeconds: 3600 });

Capped collections are fixed-size collections that support high-throughput operations that insert and retrieve documents based on insertion order. They work lik...

The `$lookup` stage performs a left outer join to an unsharded collection in the *same* database to filter in documents from the "joined" collection for process...

db.orders.aggregate([
  {
    $lookup: {
      from: "products",
      localField: "product_id",
      foreignField: "_id",
      as: "product_details"
    }
  }
]);

MongoDB supports multi-document ACID transactions since version 4.0 (for replica sets) and 4.2 (for sharded clusters). You must use a `session` to begin, commit...

A covered query is a query where all the fields in the query are part of an index, and all the fields returned in the results are also part of the same index. M...

Sharding is a method for distributing data across multiple machines. MongoDB uses sharding to support deployments with very large data sets and high throughput ...

A shard key is a field or fields that determine the distribution of documents among the cluster's shards. Choosing a good shard key (with high cardinality and e...

A replica set is a group of `mongod` instances that maintain the same data set. It provides redundancy and high availability. One node is the **Primary** (recei...

Write concern describes the level of acknowledgment requested from MongoDB for write operations to a standalone `mongod` or to replica sets or to sharded cluste...

Read preference describes how MongoDB clients route read operations to the members of a replica set. Common preferences include `primary` (default), `primaryPre...

The `$unwind` stage deconstructs an array field from the input documents to output a document for each element. Each output document is the input document with ...

{ $unwind: "$tags" }

The `$facet` stage allows you to process multiple aggregation pipelines within a single stage on the same set of input documents. Each sub-pipeline has its own ...

- **$project**: Reshapes each document in the stream, such as by adding new fields or removing existing fields. You must explicitly include all fields you want ...

A compound index is an index where a single index structure holds references to multiple fields within a collection's documents. The order of fields in a compou...

db.users.createIndex({ "lastName": 1, "firstName": 1 });

Partial indexes only index documents in a collection that meet a specified filter expression. This reduces the index size and performance overhead for index upd...

db.users.createIndex(
  { "email": 1 }, 
  { partialFilterExpression: { "age": { $gt: 18 } } }
);

You can use the `.explain("executionStats")` method to see if an index was used for a particular query.

db.users.find({ email: "test@test.com" }).explain("executionStats");

The oplog is a capped collection in the `local` database that keeps a rolling record of all data-modifying operations. Secondary members of a replica set use th...

An arbiter is a `mongod` instance that is part of a replica set but does not maintain a copy of the data set. Its purpose is to participate in elections to brea...

Common tools are `mongodump` (binary backup) and `mongoexport` (CSV/JSON backup). Use `mongorestore` and `mongoimport` to restore.

mongodump --db=interview_db --out=/backups/

The `$out` stage writes the resulting documents of the aggregation pipeline to a specified collection. If the collection exists, `$out` replaces it with the res...

{ $out: "agg_results" }

- **2d**: For data stored as points on a two-dimensional flat surface (Euclidean geometry). - **2dsphere**: For data that is stored as GeoJSON objects or legacy...

MongoDB follows the **CAP theorem** (Consistency, Availability, Partition tolerance). By default, it is a CP system. It ensures consistency via the Primary node...

MongoDB is designed to avoid joins where possible by using embedding. However, SQL-like joins can be performed across non-sharded collections using the `$lookup...

When a Primary becomes unavailable, the Secondaries hold an election to choose a new Primary. A member needs a majority of votes to become the Primary. Arbiters...

Change streams allow applications to access real-time data changes without the complexity and risk of tailing the oplog. Applications can use change streams to ...

The `.hint()` method forces the query optimizer to use a specific index. This is used when the optimizer chooses a less efficient index or a collection scan.

db.users.find({ age: 25 }).hint({ age: 1 });

WiredTiger is the default storage engine for MongoDB since version 3.2. Features include document-level concurrency control, compression (Snappy, Zlib), and che...

In a sharded cluster, orphaned documents are those that exist on a shard but technically belong to a chunk that has migrated to another shard. This can happen i...

The journal is a log that records all write operations before they are applied to the data files. It ensures that MongoDB can recover to a consistent state if t...

The working set is the portion of data (documents and indexes) that the application uses frequently and must fit in RAM for optimal performance. If the working ...

A sparse index only contains entries for documents that have the indexed field, even if the index field contains a null value. It skips documents that do not ha...

db.users.createIndex({ "twitter_handle": 1 }, { sparse: true });

Mongoose is a popular Object Data Modeling (ODM) library for MongoDB and Node.js. It provides a schema-based solution to model application data, with built-in v...

Single BSON documents in MongoDB are limited to 16 megabytes. This limit prevents documents from growing too large and consuming excessive RAM or bandwidth. Lar...

- **Vertical**: Adding more CPU, RAM, or storage to a single server. Limited by hardware capacity. - **Horizontal**: Adding more servers and distributing data a...

Read concern controls the consistency and isolation properties of the data read from the replica set or sharded cluster. Examples: `local`, `majority`, `snapsho...

Map-reduce is a data processing paradigm for condensing large volumes of data into useful aggregated results. It is generally replaced by the Aggregation Pipeli...

A MongoDB view is a read-only queryable object whose contents are defined by an aggregation pipeline. They do not store data themselves but are computed on dema...

db.createView("activeUsers", "users", [{ $match: { status: "active" } }]);

Causal consistency ensures that operations are executed in a way that respects the sequence of causal dependencies. For example, if operation A happened before ...

1. Create appropriate indexes. 2. Use Projection to return only needed fields. 3. Ensure the working set fits in RAM. 4. Use the Aggregation Pipeline for proces...

Sharding write strategies include **Hashed Sharding** (even distribution) and **Ranged Sharding** (efficient range queries). Choosing depends on application acc...

The balancer is a background process that monitors the number of chunks on each shard. If the imbalance exceeds a threshold, the balancer migrates chunks betwee...

Sessions provide a context for operations, enabling features like ACID transactions and causal consistency. A session tracks operations and ensures they are gro...

Use MongoDB's `mongostat` and `mongotop` CLI tools, or cloud solutions like **MongoDB Atlas** monitoring and Cloud Manager.

MongoDB allows you to define validation rules for collections (JSON Schema). This ensures that documents inserted or updated conform to a specific structure.

db.createCollection("students", { validator: { $jsonSchema: { ... } } });

WiredTiger provides block-level compression for collections and indexes. This reduces storage footprint significantly at the cost of some CPU usage.

Use `$sort` followed by `$limit`.

db.orders.aggregate([
  { $sort: { totalAmount: -1 } },
  { $limit: 5 }
]);

Use the `$group` stage with the `$sum` accumulator.

db.sales.aggregate([
  { $group: { _id: "$category", revenue: { $sum: "$price" } } }
]);

Use the `$size` operator in the query.

db.users.find({ tags: { $size: 3 } });

Use `updateMany()` with the `$unset` operator.

db.users.updateMany({}, { $unset: { oldField: "" } });

You can query the array field directly; MongoDB will match if any element in the array matches.

db.posts.find({ tags: "mongodb" });

First, create a `text` index on the field(s), then use the `$text` operator.

db.articles.createIndex({ content: "text" });
db.articles.find({ $text: { $search: "database" } });

Use `$ne: null` and `$exists: true`.

db.users.find({ email: { $ne: null, $exists: true } });

Use the `$inc` operator in an update operation.

db.stats.updateOne({ _id: 1 }, { $inc: { views: 1 } });

Use the `$expr` operator to use aggregation expressions within a regular query.

db.products.find({ $expr: { $gt: [ "$price", "$cost" ] } });

Use `updateMany()` with the `$rename` operator.

db.users.updateMany({}, { $rename: { "oldName": "newName" } });

Use the `$addToSet` operator.

db.users.updateOne({ _id: 1 }, { $addToSet: { tags: "new_tag" } });

Use the `$$NOW` system variable.

db.logs.aggregate([
  { $addFields: { processedAt: "$$NOW" } }
]);

Calculate the timestamp and use `$gte`.

const yesterday = new Date(Date.now() - 24*60*60*1000);
db.logs.find({ createdAt: { $gte: yesterday } });

Use the `$lookup` stage.

db.users.aggregate([
  {
    $lookup: {
      from: "posts",
      localField: "_id",
      foreignField: "author_id",
      as: "user_posts"
    }
  }
]);

Use the complex `$lookup` syntax (pipeline) or a subsequent `$filter` stage.

db.users.aggregate([
  {
    $lookup: {
      from: "posts",
      let: { userId: "$_id" },
      pipeline: [
        { $match: { $expr: { $eq: ["$author_id", "$$userId"] }, status: "published" } }
      ],
      as: "live_posts"
    }
  }
]);

Use the `$unwind` stage.

db.orders.aggregate([{ $unwind: "$items" }]);

Group, then use `$match` (equivalent to SQL HAVING).

db.users.aggregate([
  { $group: { _id: "$city", avgAge: { $avg: "$age" }, count: { $sum: 1 } } },
  { $match: { count: { $gt: 10 } } }
]);

Use an aggregation-based update (available in MongoDB 4.2+).

db.users.updateOne(
  { _id: 1 },
  [{ $set: { status: { $cond: { if: { $gt: ["$score", 50] }, then: "pass", else: "fail" } } } }]
);

Use the `$pull` operator.

db.logs.updateMany({}, { $pull: { tags: "error" } });

Use the `$type` operator.

db.users.find({ age: { $type: "string" } }); // Oops, age is string here

Run the same query with `find()` first to see which documents will be affected.

db.users.find({ inactive: true }).map(u => u._id); // Preview IDs

Sort by `_id` or timestamp descending and limit to 10.

db.logs.find().sort({ _id: -1 }).limit(10);

Use the `$near` operator with `$maxDistance` (in meters).

db.places.find({
  location: {
    $near: {
      $geometry: { type: "Point", coordinates: [ -73.96, 40.78 ] },
      $maxDistance: 5000
    }
  }
});

Move to a 'Linking' (Referencing) model or use 'Bucket' pattern (e.g., one document per 100 related items) to stay below 16MB and keep queries efficient.

Use the `mongoexport` command-line utility.

mongoexport --db=interview_db --collection=users --out=users.json