Top 77 MongoDB Interview Questions And Answers

Question 1

What are _Key Features_ of MongoDB?

Accepted Answer

MongoDB is an open-source document database that provides high performance, high availability, and automatic scaling.

Its **Key Features** are:
* Document Oriented and NoSQL database.
* Supports Aggregation
* Uses BSON format
* Sharding (Helps in Horizontal Scalability)
* Supports Ad Hoc Queries
* Schema Less
* Capped Collection
* Indexing (Any field in MongoDB can be indexed)
* MongoDB Replica Set (Provides high availability)
* Supports Multiple Storage Engines
* ACID compliance including multi-document transactions support (starting from v. 4)

Question 2

What's the difference between `replaceOne()` and `updateOne()` in MongoDB?

Accepted Answer

* With `replaceOne()` you can only _replace_ the entire document
* While `updateOne()` allows for _updating_ fields.
* Since `replaceOne()` replaces the entire document - _fields in the old document not contained in the new will be lost_.
* With `updateOne()` _new fields can be added without losing the fields_ in the old document.

For example:

```js
{
  "_id" : ObjectId("0123456789abcdef01234567"),
  "my_test_key3" : 3333
}

replaceOne({"_id" : ObjectId("0123456789abcdef01234567")}, { "my_test_key4" : 4})

// Output
{
   "_id" : ObjectId("0123456789abcdef01234567"),
   "my_test_key4" : 4.0
}

updateOne({"_id" : ObjectId("0123456789abcdef01234567")}, {$set: { "my_test_key4" : 4}})

// Output
{
   "_id" : ObjectId("0123456789abcdef01234567"),
   "my_test_key3" : 3333.0,
   "my_test_key4" : 4.0
}
```

Question 3

What is _Sharding_ in MongoDB?

Accepted Answer

**Sharding** is a method for distributing data across multiple machines. MongoDB uses sharding to support deployments with very large data sets and high throughput operations. MongoDB supports _horizontal scaling_ through [sharding](https://www.mongodb.com/docs/manual/reference/glossary/#std-term-sharding). MongoDB shards data at the _collection_ level, distributing the collection data across the _shards_ in the _cluster_.

Question 4

What is a _Replica Set_?

Accepted Answer

A replica set is a group of [`mongod`](https://www.mongodb.com/docs/manual/reference/program/mongod/#mongodb-binary-bin.mongod) instances that maintain the same data set. A replica set contains several data-bearing nodes and optionally one arbiter node. Of the data-bearing nodes, one and only one member is deemed the **primary node**, while the other nodes are deemed **secondary nodes**.

The ideas for a replica set are :

* The primary node receives all write operations. 
* The secondaries replicate the primary's oplog and apply the operations to their data sets such that the secondaries' data sets reflect the primary's data set asynchronously. If the primary is unavailable, an eligible secondary will hold an election to elect the new primary.

![](https://i.stack.imgur.com/Wr0pR.png)

Question 5

What are _Indexes_ in MongoDB?

Accepted Answer

Indexes support the efficient execution of queries in MongoDB. Without indexes, MongoDB must perform a _collection scan_, i.e. scan every document in a collection, to select those documents that match the query statement. If an appropriate index exists for a query, MongoDB can use the index to limit the number of documents it must inspect.

![https://www.mongodb.com/docs/manual/images/index-for-sort.bakedsvg.svg](https://www.mongodb.com/docs/manual/images/index-for-sort.bakedsvg.svg)

Question 6

What Is _Replication_ In MongoDB?

Accepted Answer

**Replication** is the process of synchronizing data across multiple servers.

Replication provides redundancy and increases [data availability](https://www.mongodb.com/docs/manual/reference/glossary/#std-term-high-availability). With multiple copies of data on different database servers, replication provides a level of fault tolerance against the loss of a single database server.

In some cases, replication can provide increased read capacity as clients can send read operations to different servers. Maintaining copies of data in different data centres can increase data locality and availability for distributed applications. You can also maintain additional copies for dedicated purposes, such as disaster recovery, reporting, or backup.

Question 7

What is _BSON_ in MongoDB?

Accepted Answer

**BSON** is a binary serialization format used to store documents and make remote procedure calls in MongoDB. BSON extends the JSON model to provide additional data types, and ordered fields, and to be efficient for encoding and decoding within different languages.

BSON encodes type and length information, too, making it easier for machines to parse. Consider:

```js
{"hello": "world"} →

\x16\x00\x00\x00           // total document size
\x02                       // 0x02 = type String
hello\x00                  // field name
\x06\x00\x00\x00world\x00  // field value
\x00                       // 0x00 = type EOO ('end of object')
```

Question 8

When should we _embed one document within another_ in MongoDB?

Accepted Answer

You should consider embedded documents (subdocuments) for:

* When the relationship is `one-to-few` (not many, not unlimited). For unlimited use case, you should start considering separating subdocuments into another collection.
* When retrieval is likely to happen together, that will improve performance
* When updates are likely to happen at the same time. Although starting from MongoDB 4.0, you can use multi-documents transactions, a single document transaction would be more performant
* When the field is rarely updated

Question 9

When to use MongoDB vs other document oriented database systems?

Accepted Answer

MongoDB is best suitable to store _unstructured data_. And this can organize your data into document format. These data stores don't enforce the ACID properties, and any schemas. This doesn't provide any transaction abilities. So this can scale big and we can achieve faster access (both read and write). If you wanted to work with structured data you can go ahead with RDBM.

Question 10

What is use of _Capped Collection_ in MongoDB?

Accepted Answer

**Capped collections** allow you to define a fix length/size collection. After the size/no of documents have been reached it will override the oldest document to accommodate new documents. It is like a circular buffer. Capped collections support high-throughput operations that insert and retrieve documents based on insertion order.

Consider the following potential use cases for capped collections:
* Store log information generated by high-volume systems. Inserting documents in a capped collection without an index is close to the speed of writing log information directly to a file system. 
* Cache small amounts of data in a capped collections.

Top 77 MongoDB Interview Questions

What are Key Features of MongoDB?

What is a Replica Set?

What is Sharding in MongoDB?

What's the difference between replaceOne() and updateOne() in MongoDB?

What Is Replication In MongoDB?

What is BSON in MongoDB?

What are Indexes in MongoDB?

When should we embed one document within another in MongoDB?

What is BSON and exactly how is it different from JSON?

How is data stored in MongoDB?

Does MongoDB support ACID transaction management and Locking functionalities?

Is there an upsert option in the MongoDB insert command?

What is a Covered Query in MongoDB?

What is oplog and how is it relevant to replication process?

How can you achieve Primary Key - Foreign Key relationships in MongoDB?

How can you achieve Transaction in MongoDB?

What is an Aggregation Pipeline in MongoDB?

Explain advantages of BSON over JSON in MongoDB?

What is a Cluster in MongoDB?

When shall we use Azure Table Storage over Azure SQL?

Why would you use Projection Document?

Does the sort order matter for Compound Index in MongoDB?

How do the MongoDB Journal File and Oplog Differ?

How does MongoDB handle caching?

What is TTL Collection in MongoDB?

In MongoDB what is the difference between Sharding and Replication?

What is Shard Key in MongoDB and how does it affect development process?

What is the difference between One-to-Many vs One-to-Few in MongoDB Schema Design?

What types of One-to-N schema designs you can use in MongoDB?

Can you create an index on an array field in MongoDB? If yes, what happens in this case?

Explain the structure of ObjectID in MongoDB

When to use MongoDB vs other document oriented database systems?

What is use of Capped Collection in MongoDB?

Does Mongodb support Foreign Key constraints?

Should I normalize my data before storing it in MongoDB?

What does MongoDB not being ACID compliant really mean?

When to use CouchDB over MongoDB and vice versa?

What are Primary and Secondary Replica sets?

What is Selectivity of the query in MongoDB?

How Compound Index Prefix affects Sort operation in MongoDB?

How does Sharding affect Concurrency in MongoDB?

What does it mean to fit working set into RAM for MongoDB?

How does MongoDB provide Concurrency?

Explain what is horizontal scalability?

When and why to use Hashed Sharding in MongoDB?

How replication works in MongoDB?

Why is a Covered Query important?

When to use Redis or MongoDB?

Is MongoDB schema-less?

How does MongoDB ensure high availability?

How would you choose between Azure Table Storage vs MongoDB?

What's the advantage of the backup features in Ops Manager versus traditional backup strategies?

What are three primary concerns when choosing a data management system?

What are the differences between MongoDB and MySQL?

How much faster is Redis than MongoDB?

When shall you Shard your MongoDB data?

How to condense large volumes of data in Mongo?

What is Index Cardinality and why does it matter?

Where does MongoDB stand in the CAP theorem?

How to query MongoDB with like?

Write equivalent MongoDB statement for this SQL aggregation statement

Is possible in MongoDB to select collection's documents like in SQL SELECT * FROM collection WHERE _id IN (1,2,3,4)?

Find objects between two dates in MongoDB

How do I perform the SQL JOIN equivalent in MongoDB?

How can I combine data from multiple collections into one collection?

How to query MongoDB with %like%?

How do I create a Compound Index in MongoDB?

Will you create Compound Index with sex first or name first? Explain.

How to check if a field contains a substring?

Update MongoDB field using value of another field

MongoDB relationships. What to use - embed or reference?

How to remove a field completely from a MongoDB document?

How to get the last N records from find?

How to find MongoDB records where array field is not empty?

How to find document with array that contains a specific value?

Is it possible to update MongoDB field using value of another field?

How would you design the One-to-Squillions relationship in MongoDB?

What's the difference between `replaceOne()` and `updateOne()` in MongoDB?

Is there an `upsert` option in the MongoDB insert command?

What is `oplog` and how is it relevant to replication process?

What is the difference between `One-to-Many` vs `One-to-Few` in MongoDB Schema Design?

What types of `One-to-N` schema designs you can use in MongoDB?

Explain the structure of `ObjectID` in MongoDB

How to query MongoDB with `like`?

Is possible in MongoDB to select collection's documents like in SQL `SELECT * FROM collection WHERE _id IN (1,2,3,4)`?

How do I perform the SQL `JOIN` equivalent in MongoDB?

How to query MongoDB with `%like%`?

Will you create Compound Index with `sex` first or `name` first? Explain.

How to get the last `N` records from `find`?

How would you design the `One-to-Squillions` relationship in MongoDB?