A Complete Infosys MongoDB Interview Overview
MongoDB is a most used NoSQL database, which is known for its flexibility, scalability, unstructured data etc. MongoDB is a common skill required for developers because many of the top companies use MongoDB. If you are at the start of your career or planning to take a step up, then it is essential to prepare thoroughly for your interview if you are gunning for a role at MongoDB.
We have listed down all the Infosys MongoDB interview questions from basic to advanced level in this article. Answering these questions will gain you confidence, covering essential topics, and nailing your interview.
What is MongoDB, and How is It Different from Traditional SQL Databases?
MongoDB does not use the table-based relational database structure, as it is a NoSQL database. It uses a schemaless approach and a document storage model that samples data in BSON (Binary JSON) file format.
MongoDB uses JSON-like documents, which avoids the row and column structure of SQL databases, so this facilitates the work with non-structured data and offers a more flexible schema.
Describe BSON andits importance in MongoDB
MongoDB stores documents in BSON (Binary JSON), which is a binary-encoded serialization format. BSON is a binary-encoded serialization format that is based on JSON, but it adds support for data types like dates and binary data, and is optimized for space and scan speed. MongoDB is more efficient with textless data (e.g. JSON can be in a binary format) than JSON as such.
Define Structure of a Document Find in MongoDB
A MongoDB document is a document that contains key-value pairs and behaves similar to a JSON Object The key is a string and value can be string, number, array, nested document … etc.
Example:
{
"_id": ObjectId("507f1f77bcf86cd799439011"),
"name": "Alice",
"age": 25,
"address": {
"street": "123 Main St",
"city": "Anytown",
"state": "CA"
},
hobbies："reading", "cycling"
}
How Collections And Databases Work In MongoDB?
Database: A encasement for a collection (just like SQL database)
Collection: A collection is like a table in SQL, but schema-less, so 0 Documents must have the same fields.
A trick, for instance, to mydatabase, can exist in that part of the world of a users collection.
MongoDB: How does it provide High Availability and Scalability?
MongoDB provides high availability and scalability with its replica sets and sharding.
If there is a failure, then replica sets also come with redundancy and failover capabilities: meaning that your data is always there.
Sharding is a form of horizontal partitioning in a database or search engine and aims to separate very large datasets into smaller, more manageable pieces (shards) such that each may be hosted on a separate server.
Replica Sets in MongoDB: Explained
In MongoDB, a replica set is a collection of mongod instances that holds the same data set.
A replica set includes a primary node and a number of secondary nodes.
All write operations go to the primary nodes, and data is replicated to the secondary nodes that may serve read operations.
In the event of a primary node failure, a new primary is automatically selected to ensure high availability.
Benefits of Using MongoDB Compared to Other Databases
Flexible: MongoDB is document-oriented and supports dynamic schemas.
Scalability: You can scale out with built-in sharding.
Redundancy & Automatic Failover (High Availability): Since replica sets maintain replica of primary, it also provide automatic failover.
Performance — It stores and retrieves data, in BSON format, on disk and in memory bandwidth-efficiently.
Humans — JSON-like documents are special because they make it easy for developers to communicate with data.
Now, how to create one new database and collection inside the MongoDB?
Creating new database and collection on mongo shell relative to MongoDB
use mydatabase
db. db.createCollection('mycollection')
This command either switches to mydatabase or create it if not exist then creates a new collection called mycollection.
What Is Sharding and How Does It Work in MongoDB?
MongoDB supports this Sharding functionality which allows us to disperse the data in various servers. Sharding enables horizontal scaling by dividing large datasets into smaller, more easily managed chunks known as shards.
They have separate databases storing partial data in every shard.
MongoDB sharding design will automatically balance data and load across shards so you will not have to do any extra work to ensure high throughput.
MongoDB CRUD Operations — The Basic Syntax
CRUD operations in MongoDB can perform things like create(data insert), read(data select), update and delete operations.
Create: db. collection. add({name: "Alice", age: 25})
Read: db. collection. find({ name: "Alice" })
Update: db. collection. updateOne({ name: "Alice" }, { $set: { age: 26 } })
Delete: db. collection. deleteOne({ name: "Alice" })Querying Some Basic Information from MongoDB
All the basic querying you do in MongoDB can be through find, which lets you query for documents that match a specific criterion.
Example:
db. collection. find({ age: { $gte: 20 } })
Where age >= 20 This gets all documents from the collection where age field is larger than or equal to 20.
What is an Index and Create one in MongoDB?
MongoDB uses a data structure called Index to provide faster data retrieval from any collection. Using createIndex, you can define the index.
In other words, to put an index on name field:
db. collection. createIndex({ name: 1 })Consistency in MongoDB: What is More Consistency?
MongoDB has some mechanisms that help to maintain data consistency.
Write-Ahead Logging (Journaling): MongoDB incorporates write-ahead logging to ensure data integrity.
Write Concerns: It defines how much acknowledgment requested from MongoDB for write operations(e.g primary only, primary & secondaries).
Replica Sets: Data is replicated on multiple nodes, enough so that read concerns can be configured to the certainty level of data consistency.
MongoDB Data Import & Export Step by Step Process
MongoDB enables data import and export using mongoimport and mongoexport tools. They enable you to easily import data from JSON, CSV or TSV files into MongoDB, as well as to export data from MongoDB collections to JSON or CSV files.
Import Data:
mongoimport —db mydatabase —collection mycollection —file data. json
This command import data from data into collection mycollection of database mydatabase
Export Data:
So for example: mongoexport –db mydatabase –collection mycollection –out data json
It exports data from the collection mycollection in the database mydatabase into data. json.
Understanding MongoDB Aggregation Pipelines and Their Usage
An aggregation pipeline is a framework for data aggregation, based on the concept of data processing pipelines. After the documents have been processed through the pipeline Processing core, the documents are aggregated into results through a multi-stage pipeline. Every stage does some operation on input documents and passes results to next stage.
db.orders.aggregate([
Steppipe 1: Filter documents by status: { $match: { status: "A" } },
{ $group: { _id: "$custid", total: { $sum: "$amount" } } } // Stage 2: grouping customer id and take sum of amount
$sort: { total: -1 } // Stage 3: Order by the total descending
])
In this example:
Stage 1 ($match): It filters documents with status as “A”.
Stage 2 ($group): Groups the documents by customer ID and sums the amount for each group.
Stage 3 ($sort) sorts the results based on the total amount from the highest to the lowest.
Aggregation pipelines provide a robust and intuitive mechanism to perform such operations directly within MongoDB.
What is the Aggregation Framework in MongoDB
MongoDB Aggregation Framework is used to process and transform the documents of a collection.
This works by running documents through a multi-stage pipeline each stage performing an operation on the data (e.g. filter, a sort, a grouping, reshape and compute some aggregations).
This allows you to build complex data transformations and analytics in the database itself.
Aggregate operations in MongoDB
The aggregate method is the MongoDB operation that processes data and returns results in the form of aggregation operations. This function accepts an array of pipeline stages, with each stage representing a step in the data processing pipeline.
For Instance: Display total sales per product:
db.sales.aggregate([
{ $match: { status: "completed" } }, // Match only the completed sales
$group: { _id: "$product", totalSales: { $sum: "$amount" } }, // Group by product & total amount of sales
{$sort :{ totalSales : -1 }} // Sort by totalSales in Descending order
])In MongoDB, Write Concern is the level of acknowledgment requested from MongoDB for write operations.
In MongoDB, write concern is the level of acknowledgment requested from a MongoDB for write operations. It specifies the number of nodes that must acknowledge the write operation for it to be accepted as successful. You can set write concern from “acknowledged” (default) to “unacknowledged”, “journaled” and different types of “replica acknowledged”.
Write concern is critical to the compromise between durability and performance of data. High write concern also does write data on disk and replica but with a little latency so it is safe but have a performance hit.
Still, if you are totally new to MongoDB, you can Figure out what is TTL Indexes and How to Use TTL Indexes in MongoDB.
In MongoDB, TTL (Time To Live) Indexes are unique type of indexes that remove documents from a collection after a specified period of time. They are often employed for time-sensitive data — things that should expire, like sessions, logs, or temporary data. A TTL index can be created by providing an expiry time in seconds
Ex: Delete documents 1 hour after createdAt
db. sessions. createIndex( { "createdAt": 1 }, { expireAfterSeconds: 3600 } )
it will delete documents from the sessions collection 1 hour (3600 seconds) after the value of the createdAt field.
How to Dealing With Schema Design and Data Modeling in MongoDB?
Schema design and data modeling in MongoDB refers to the way data is structured and stored in a document-based database. MongoDB is schema-less like NoSQL, which is an advantage as well as a challenge apart from SQL databases. Schema design considerations Schema design considerations should include:
Embedding vs referencing − When dealing with related data, you must decide if you want to embed that data within a single document or use references between documents.
Document-oriented: Building documents with the design of the application query patterns to read/write faster.
Indexing: Adding indexes to aid in query speed.
Data Duplication — Accepting a degree of data duplication in exchange for read-optimized performance.
Sharding– If horizontal scaling is required, then it is important to design the schema upfront to support sharding.
Use of GridFS in MongoDB What is GridFS and When We Use That?
MongoDB GridFS is a standard for storing and retrieving files that exceed the BSON-document size limit of 16 MB. When the size of files exceeds the 16 MB BSON-document size limit, or if you want to efficiently retrieve parts of the file.
GridFS is a specification for storing and retrieving large files that exceed the BSON-document size limit of 16 MB. files and fs. chunks. This makes it possible to quickly store, and later retrieve large files as images, videos, or large data sets.
What is MongoDB Compass Tool and its Features
MongoDB Compass is the official GUI tool for MongoDB, which allows you to see your data visually. It offers features such as:
Schema Visualisation — Explore your schema with info on field types, distributions, etc
Query building: Build and run queries with a visual interface.
Aggregation Pipeline: Create and execute aggregation pipelines.
Index Management — Design and manage the indexes needed to serve queries faster
Performance Monitoring: Track database performance metrics — including slow queries, index utilization, and resource usage.
Schema validation: Set up and apply rules to govern the validation of data and preserve its integrity.
Import/Export Data: Simple data import and export between MongoDB and JSON/CSV files.
