I am sharing top 41 MongoDB Interview Questions, which will help you to crack the MongoDB Interview.

Ans:- MongoDB is a NoSql Database, it is based on BSON.

Ans:- Mongo DB is not considered as a 32-bit system because for running the 32-bit MongoDB, with the server, information and indexes require 2 GB. That is why it is not used in 32-bit devices

Ans:- use databaseName

Ans:- db.dropDatabse() command is used to drop a database.

Ans- In MongoDB, a collection is a group of MongoDB documents.

Ans:- db.createCollection(name,options)

Ans:- db.collectionName.drop()

Ans:- db.collectionName.insertOne() is used to add single document in the collection.
db.collectionName.insertMany() is used to add multiple documents in the collection.

Ans:- The save() method is used to replace the existing document with a new document.

Ans:- If you want to update single document then use

db.collectionName.updateOne()

If you want to update Multiple documents then use

db.collectionName.updateMany()

Ans:- The remove() method is used to remove a document from a collection.

Ans:- Projection is used to select only the necessary data. It does not select the whole data of a document.
readmore…

Ans:- The pretty() method is used to show the results in a formatted way.

Ans:- The limit() method is used to limit the records in the database.

Ans:- The syntax of the limit() method is as follows

>db.COLLECTION_NAME.find().limit(NUMBER)

Ans:- In MongoDB, the following syntax is used for sorting documents:

>db.COLLECTION_NAME.find().sort({KEY:1})

Note: 1 is used for ascending order.
-1 is used for descending order.

Ans:- The syntax of the skip() method is as follows:

>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

Ans:-

db.users.find({name: /a/}) //like '%a%'
db.users.find({name: /^pa/}) //like 'pa%'
db.users.find({name: /ro$/}) //like '%ro'

Ans:- The mongodump command is used to create a backup of the database.

Ans:- The mongorestore command is used to restore into the database.

Ans:- indexes are used to increase the performance to get the records from the database.

Ans:-

db.collectionname.createIndex({'documentkeyname':1})

Ans:-

db.collectionName.getIndexes()

Ans:- MongoDB stores BSON objects in collections. The concatenation of the database name and the collection name (with a period in between) is called a “namespace”.

Ans:- MongoDB replication is distributed to the data across different machines.

Ans:- GridFS is used for storing and retrieving large files, such as audio, image, and video files.

Ans:- Journaling is used for safe backups in MongoDB.

Ans:- Profiler is used to show the performance characteristics of every operation against the database.

Ans:- MongoDB stores data in the form of documents, which are JSON-like field and value pairs.

Ans:- Replication provides redundancy, and it increases data availability.

Ans:- Embedded documents capture relationships between data by storing related data in a single document structure.

Ans:- Vertical scaling adds more CPU and storage resources to increase capacity.

Ans:- Horizontal scaling divides the dataset and distributes data over multiple servers, or shards.

Ans:- The aggregation pipeline is a framework for performing aggregation tasks. The pipeline is used to transform documents into aggregated results.

Ans:- 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.

Ans:- MMAPv1 and WiredTiger are two storage engines used by MongoDB.

Ans:- MongoDB Profiler allows you to analyze all the queries which are being run by the database system.
Note:- MongoDB would be to use the query profiler to track and diagnose slow queries.

Ans:- MongoDB uses documents to store data into the collections.

Ans:- A replica can be specified as a group of mongo instances that host the same data set. In a replica set, one node is primary, and another is secondary. All data is replicated from primary to secondary nodes.

Ans:- In MongoDB, primary nodes are the node that can accept write. These are also known as master nodes. The replication in MongoDB is a single master so, only one node can accept write operations at a time.
Secondary nodes are known as slave nodes. These are read-only nodes that replicate from the primary.

Ans:- Ad-hoc queries are the queries not known while structuring the database. So, MongoDB provides ad-hoc query support which makes it so special in this case.

firstly open the terminal. If you have mongo credentials then write the below command.

mongo -u admin
Enter password:

Note:- where admin is a username

If you did not create credentials then you can directly login write the command

mongo

Now, create the database through below command
use DatabaseName

 > use employee_management
 > switched to db employee_management

if you want to see all databases then write the below command.

> show dbs

Note:- it will show all databases which has collection.

db.createCollection(name, options) is used to create collection in MongoDB. when you create a document then the collection is automatically created if it does not exist. The collection is like a table in RDBMS.

> db.createCollection("collectionName",options);

collectionName:- is a string type, specifies the name of the collection to be created.

options:- is a document type, specifies the memory size and indexing of the collection. It is an optional parameter.

	
> db.createCollection("employees");

How to create Collection through Document?
When you create a document then it checks collection is exists or not if not exists then create automatically.

	
> db.collectionName.insert(objectValue);
> db.users.insert({
	"name":"John",
	"age":35
});

Now, check all collection in the database

	
> show collections

To insert document in the collection through multiple methods like insert(), insertOne() and insertMany(). it works like insert row into table in RDBMS.

Syntax:-

> db.collectionName.insert(document);

In RDBMS:-

insert into tableName(field1,field2...) values('Value1','Value2'..)

Example:-

db.employees.insert({
	name:"John",
	age: 35,
	department:"department A",
	salary:100000
})

if the document is inserted then show a message

This method is used to insert only one document in the collection.

Syntax:-

db.collectionName.insertOne(Document);

Example:-

> db.employees.insertOne({
	name:"Rom",
	age: 30,
	department:"department A",
	salary:50000
})

after insert successfully then show message

Note:- When use insertOne() method then show insert document id, it is generated automatically and it has unique value in the collection.

This method is used to add multiple documents in the collection.

Syntax:-

db.collectionName.insertMany(multipleDocuments)

Example:-

> db.employees.insertMany([{
	name:"Tony",
	age: 31,
	department:"department B",
	salary:40000
},
{
	name:"Peter",
	age: 32,
	department:"department B",
	salary:30000
},
{
	name:"Andrew",
	age: 33,
	department:"department C",
	salary:20000
}
])

After insert successfully then show messages

To update the documents in the collection through multiple methods like update(), updateOne(), updateMany() . it works like update row into table in RDBMS.

Syntax:-

> db.collectionName.update({whereCondition},{newData});

In RDBMS:-

update tableName set field1='Value1',field2='Value2' where conditions

Example:- Suppose, You have employees collection

[
	{
		"_id" : ObjectId("5fdc8b842649b8748d4ec107"),
		"name" : "John",
		"salary" : 100000
	},
	{
		"_id" : ObjectId("5fdcdb87b6dad382104b0f86"),
		"name" : "Rom",
		"salary" : 50000
	}
]

Now, you want to update employee salary where name is John.

> db.employees.update({name:"John"},{$set:{salary:200000}})

if the document is updated then show a message

this method is used to update only one document in the collection.

Syntax:-

> db.collectionName.updateOne({whereCondition},{newData});

Example:-

> db.employees.updateOne({name:"Rom"},{$set:{salary:70000}})

after update successfully then show message

This method is used to update multiple documents in the collection.

Syntax:-

> db.collectionName.updateMany({whereCondition},{newData})

This method is used to replace exists documents with the new document.

Syntax:-

> db.collectionName.save({whereCondition},{newData})

There are multiple methods in MongoDB to delete the documents from the collections like remove(), deleteOne(), deleteMany() methods. it works like a delete a row from the table in RDBMS.

Syntax:-

> db.collectionName.remove({whereCondition},justOne);

justOne:- (Optional) if set to true or 1, then remove only one document.

In RDBMS:-

delete from tableName where condition=someValue

Example:-
Suppose, you have employees collection

[
	{
	"_id" : ObjectId("5fdc8b842649b8748d4ec107"),
	"name" : "John",
	"age" : 35,
        "department":"department A"
	},
	{
	"_id" : ObjectId("5fdcdb87b6dad382104b0f86"),
	"name" : "Rom",
	"age" : 31,
        "department":"department A"
	},
	{
	"_id" : ObjectId("5fdcdb87b6dad382104b0f87"),
	"name" : "Mathew",
	"age" : 32,
        "department":"department A"
	}
]

Now, you want to delete document where name is Rom

db.employees.remove({name:"Rom"},1)

if the document is deleted then show a message.

this method is used to delete one document from the collection.

Syntax:-

db.collectionName.deleteOne({whereCondition})

Example:-

db.employees.deleteOne({name:"John"});

Output:-

this method is used to delete multiple documents from the collection.

Syntax:-

db.collectionName.deleteMany({whereCondition})

Example:-

db.employees.deleteMany({department:"department A"});

Output:-

this method is used to delete all documents from the collection.

Syntax:-

db.collectionName.remove({});

after delete successfully then show message

Example:-

db.employees.remove({})

MongoDB projection is used to get the necessary data of the documents from the collection.

this method is used to get the documents from the collection.

Syntax:-

db.collectionName.find();

Example:- Suppose you want to get all records from the employees collection.

db.employees.find();

It will show all documents data and results will be in object format.

first parameter in find() method is used for where condition.

Syntax:-

db.collectionName.find({where_condition});

Example:-
Suppose, you want to get record where department is department C

db.employees.find({department:"department C"});

If you want to find specific data from the document then use two parameters where first parameter is used for where condition while second parameter is used to get specific data from the collection through {key_name:1}.
Syntax:-

db.collectionName.find({whereCondition},{key_name:1});

Example:-

db.employees.find({},{name:1});

Output:-

Note:- _id value will show automatically.

_id will always display when you get the data if you do not want this then use _id:0

db.employees.find({},{_id:0,name:1});

Output:-

this method is used to get the only one record from the document.

Example:-

db.employees.findOne({},{name:1});

Output:-

this method is used to get the result into Array format.

db.employees.find().toArray();

Output:-

In MongoDB, limit() method is used to get the limit of documents from the collection. this method has only one parameter which should be numeric only.

Syntax:-

 db.collectionName.find().limit(number);

Suppose, you have employees collection which has 3 documents.

Now, if you want to get only one documents then you have to use the limit() method.

> db.employees.find().limit(1).toArray();

Output:-

In MongoDB, sort() method is used to get the documents in ascending or descending order corresponding to the document key.

to get the documents in the ascending order through sort({key_name:1}) method

Syntax:-

 db.collectionName.find().sort({key_name:1});

Suppose, you have employees collection

[
	{
		"_id" : ObjectId("5f26e736deec6e20ea057831"),
		"name" : "John",
		"age" : 35,
		"department" : "department A",
		"salary" : 200000
	},
	{
		"_id" : ObjectId("5f26e7c0deec6e20ea057832"),
		"name" : "Rom",
		"age" : 30,
		"department" : "department A",
		"salary" : 70000
	},	
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057835"),
		"name" : "Andrew",
		"age" : 33,
		"department" : "department C",
		"salary" : 20000
	}
]

Now, you want to get the documents in ascending Order corresponding to name wise.

> db.employees.find().sort({name:1}).toArray();

Output:-

[
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057835"),
		"name" : "Andrew",
		"age" : 33,
		"department" : "department C",
		"salary" : 20000
	},
	{
		"_id" : ObjectId("5f26e736deec6e20ea057831"),
		"name" : "John",
		"age" : 35,
		"department" : "department A",
		"salary" : 200000
	},
	
	{
		"_id" : ObjectId("5f26e7c0deec6e20ea057832"),
		"name" : "Rom",
		"age" : 30,
		"department" : "department A",
		"salary" : 70000
	}
]

to get the documents in the descending order through sort({key_name:-1}) method
Syntax:-

 db.collectionName.find().sort({key_name:-1});

Suppose, you want the get the documents from the employees collection in descending order corresponding to name wise.

> db.employees.find().sort({name:-1}).toArray();

Output:-

[
	
	{
		"_id" : ObjectId("5f26e7c0deec6e20ea057832"),
		"name" : "Rom",
		"age" : 30,
		"department" : "department A",
		"salary" : 70000
	},
	
	{
		"_id" : ObjectId("5f26e736deec6e20ea057831"),
		"name" : "John",
		"age" : 35,
		"department" : "department A",
		"salary" : 200000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057835"),
		"name" : "Andrew",
		"age" : 33,
		"department" : "department C",
		"salary" : 20000
	}
]

In MongoDB, skip() method is used to skip the documents from the collection.
We can use the skip method to implement pagination logic.
Syntax:-

 db.collectionName.find().skip(numberOfDocument);

Suppose, you have employees collection and it has 5 documents

[
	{
		"_id" : ObjectId("5f26e736deec6e20ea057831"),
		"name" : "John",
		"age" : 35,
		"department" : "department A",
		"salary" : 200000
	},
	{
		"_id" : ObjectId("5f26e7c0deec6e20ea057832"),
		"name" : "Rom",
		"age" : 30,
		"department" : "department A",
		"salary" : 70000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057833"),
		"name" : "Tony",
		"age" : 31,
		"department" : "department B",
		"salary" : 40000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057834"),
		"name" : "Peter",
		"age" : 32,
		"department" : "department B",
		"salary" : 30000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057835"),
		"name" : "Andrew",
		"age" : 33,
		"department" : "department C",
		"salary" : 20000
	}
]

Now, you want to get the documents which are starting from the 3rd document.

> db.employees.find().skip(2).toArray();

Output:-

[
	
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057833"),
		"name" : "Tony",
		"age" : 31,
		"department" : "department B",
		"salary" : 40000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057834"),
		"name" : "Peter",
		"age" : 32,
		"department" : "department B",
		"salary" : 30000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057835"),
		"name" : "Andrew",
		"age" : 33,
		"department" : "department C",
		"salary" : 20000
	}
]

In SQL Database, there are many ways to create the join between two or more tables like
Left Join
Right Join
Inner Join
Full Join
Self Join

But MongoDB is a NoSQL Database so It has one method to join between two or more collection through lookup().

Syntax:-

db.collectionName.aggregate([
    { $lookup:
       {
         from: 'otherCollection',
         localField: 'collection_fieldname',
         foreignField: 'otherCollection_fieldname',
         as: 'collectionDetails'
       }
     }
    ]).toArray();

Suppose, You have two collections First is employees collection which has 3 documents and every document has 5 key fields like _id, name, age, department and salary.

[
	{
		"_id" : ObjectId("5f26e736deec6e20ea057831"),
		"name" : "John",
		"age" : 35,
		"department" : "department A",
		"salary" : 200000
	},
	
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057833"),
		"name" : "Tony",
		"age" : 31,
		"department" : "department B",
		"salary" : 40000
	},
	
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057835"),
		"name" : "Andrew",
		"age" : 33,
		"department" : "department C",
		"salary" : 20000
	}
]

2) Second collection is department. which has 4 key fields like _id, name, floor and facility.

[
	{
		"_id" : ObjectId("5f27bfaddeec6e20ea057836"),
		"name" : "department A",
		"floor" : 5,
		"facility" : "standard"
	},
	{
		"_id" : ObjectId("5f27bfaddeec6e20ea057837"),
		"name" : "department B",
		"floor" : 4,
		"facility" : "good"
	},
	{
		"_id" : ObjectId("5f27bfaddeec6e20ea057838"),
		"name" : "department C",
		"floor" : 3,
		"facility" : "normal"
	}
]

Now you want to get the employees collection document with department details

db.employees.aggregate([
    { $lookup:
       {
         from: 'department',
         localField: 'department',
         foreignField: 'name',
         as: 'departmentDetails'
       }
     }
    ]).toArray();

Output:-

MongoDB count() method is used to get the number of documents in the collection.

Syntax:-

db.collectionName.find().count();

Suppose, you have employees collection and which has 5 documents

[
	{
		"_id" : ObjectId("5f26e736deec6e20ea057831"),
		"name" : "John",
		"age" : 35,
		"department" : "department A",
		"salary" : 200000
	},
	{
		"_id" : ObjectId("5f26e7c0deec6e20ea057832"),
		"name" : "Rom",
		"age" : 30,
		"department" : "department A",
		"salary" : 70000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057833"),
		"name" : "Tony",
		"age" : 31,
		"department" : "department B",
		"salary" : 40000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057834"),
		"name" : "Peter",
		"age" : 32,
		"department" : "department B",
		"salary" : 30000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057835"),
		"name" : "Andrew",
		"age" : 33,
		"department" : "department C",
		"salary" : 20000
	}
]

Now get the number of documents in the employee’s collection.

db.employees.find().count();

Syntax:-

db.employees.find({where_condition}).count();

Suppose, you want to get the number of employees which has department B

db.employees.find({department:"department B"}).count();

Aggregation has the most important role in MongoDB. MongoDB Aggregation operations process data records and return computed results. Aggregation operations group values from multiple documents together and can perform a variety of operations on the grouped data to return a single result.

to perform the aggregate function in MongoDB, aggregate() is the function to be used. Following is the syntax for aggregation :

db.collection_name.aggregate(aggregate_operation)

Suppose, You have Employees collection which has multiple documents.

[
	{
		"_id" : ObjectId("5f26e736deec6e20ea057831"),
		"name" : "John",
		"age" : 35,
		"department" : "department A",
		"salary" : 200000
	},
	{
		"_id" : ObjectId("5f26e7c0deec6e20ea057832"),
		"name" : "Rom",
		"age" : 30,
		"department" : "department A",
		"salary" : 70000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057833"),
		"name" : "Tony",
		"age" : 31,
		"department" : "department B",
		"salary" : 40000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057834"),
		"name" : "Peter",
		"age" : 32,
		"department" : "department B",
		"salary" : 30000
	},
	{
		"_id" : ObjectId("5f26e9dedeec6e20ea057835"),
		"name" : "Andrew",
		"age" : 33,
		"department" : "department C",
		"salary" : 20000
	}
]

Now We want to get the total of employees corresponding to department wise.

 db.employees.aggregate([{$group : {_id : "$department", total_employee : {$sum : 1}}}])

Output:-

Different Expression which is used by an aggregate function

MongoDB provides role-based access control. A user is granted one or more roles that determine the user’s access or privileges to MongoDB resources and the actions that a user can perform.

Syntax:-

> db.createUser(
{	
user: "userName",
pwd: "userPassword",
roles:[{role: "roleName" , db:"DBName"}
]
})

Note:- roles are read and readWrite

read:- User can access only for read the data from the database.

readWrite:- User can access for read and modify the database.

Example:- If user can access only read the database.

> db.createUser(
{	
user: "userName",
pwd: "userPassword",
roles:[{role: "read" , db:"DBName"}
]
})

Example:- If user can access read and modify the database.

> db.createUser(
{	
user: "userName",
pwd: "userPassword",
roles:[{role: "readWrite" , db:"DBName"}
]
})

Note:- A user can have different role for differnt database like

> db.createUser(
{	
user: "userName",
pwd: "userPassword",
roles:[{role: "readWrite" , db:"DBName1"},
       {role: "read" , db:"DBName2"}
]
})

to remove the collection from the database through db.collectionName.drop() method.
Syntax:-

db.collectionName.drop()

Note:- if the collection exists then show message true if the collection does not exist then show message false;

Suppose, You have two collections department and employees. Now, check the collections in MongoDB

show collections

Output:-

Example:-

db.employees.drop()

Output:-

Now get the collection

show collection

Output:-

There are different ways to install MongoDB on the different operating systems but I am showing only for ubuntu and Window. There are two ways of installing MongoDB on Ubuntu systems.

1) Install MongoDB from apt repository

2) Install MongoDB from a downloaded.deb package

but I am representing through command base

Step 1:- Import MongoDB public GPG Key:

Before you can install any package from MongoDB apt repository, you need to download and import GPG key to your system.

wget -qO - https://www.mongodb.org/static/pgp/server-4.2.asc | sudo apt-key add -

Step 2:- Add MongoDB 4 APT Repository on Ubuntu 18.04 / Ubuntu 16.04

Ubuntu 18.04:

echo "deb [ arch=amd64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/4.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.2.list

Ubuntu 16.04:

echo "deb [ arch=amd64 ] https://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/4.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.2.list

Step 3:- Install MongoDB 4 on Ubuntu 18.04 / Ubuntu 16.04

sudo apt update
sudo apt install -y mongodb-org

The service name is mongod now you can start the application by below command:

sudo systemctl enable --now mongod

Check Mongo status

sudo systemctl status mongod

Note:- If it is showing active (running) means MongoDB is running perfectly.

Step1:-Firstly click on the URL https://www.mongodb.com/try/download/community after that select the version and select the Platform as a Window and select the package as msi after that click on download button.

Step2:- Now, double click on the msi file which is installed after that click on the next button.

Step3:- Now, click the next button.

Step4:- Now, You can change the path, where you want to install otherwise it will be install on C drive and after that click the next button.

Step5:- Now, click the next button.

Step6:- Now, click the install button.

Step7:- Now, MongoDB is started to installing.

Step8:- Now, MongoDB is installing is going on.

Step9:- Now, MongoDB Compass is loading.

Step8:- Now, MongoDB is installed and click on the finish button.

MongoDB is a NoSQL Database. It is an open-source document-oriented database written in C++. it is used for a high volume of data storage. It is not a relational database. It has important features like indexing, regular expression, sharding data, etc.

Key Features:

1. Document-Oriented: Data is stored in collections of documents (similar to rows in a table), which can have various fields and structures.

2 Flexible Schema: MongoDB allows documents to have different structures, meaning fields can be added or removed dynamically.

3. Scalability: MongoDB is designed for horizontal scalability, meaning you can distribute your data across multiple servers easily.

4. High Performance: It’s optimized for high write and read throughput, making it suitable for real-time applications.

5. Indexing and Aggregation: MongoDB supports indexing, allowing for fast querying, and has powerful aggregation features for data processing.

6. Replication and Sharding: It provides features like replication for high availability and sharding for distributing data across multiple machines.

Advantages:-

Schemaless

Scalability

Performance

High Availability

etc.

Note:- Datastore in the MongoDB as a key-value format.

Example:-

employees collection

{
	name:"John",
	age:35,
	department:"Department A"

}

Mongo DB works based on collection and Document

Collection:- Collection is a group of MongoDB documents. It is the equivalent of an RDBMS table but it has not enforced the same structure of the document so it is possible documents have different structures in the collection.

Document:- it is based on key-value pairs and document the same as a row in RDBMS. Documents have a dynamic schema. Dynamic schema means that documents in the same collection do not need to have the same set of fields or structures.

Example:- employees collection
One Document has this structure

{
	name:"John",
	age:35,
	department:"Department A"

}

The second Document has a different structure

{
	name:"John",
	age:35,
	skill:["NodeJS","Angular","MongoDB","MySQL"],
	department:"Department A",


}

compare RDBMS and Mongo DB structure

db.dropDatabase() method is used to drop the database.

Note:- When you drop the database then all collections and documents will be deleted off from this database.

Syntax:-

use databaseName
> db.dropDatabase()

Example:- Firstly check all database

show dbs

Output:-

Now delete the database

use employee_management
> db.dropDatabase()

Now check the database

show dbs

Output:-

Indexing is the most important part of every database. It is basically used to fast retrieve data from the database.

Indexing is mainly used to filter data in a fast manner from the database that is the reason it is most important.

Example:- Suppose you have a collection of thousands of documents and you want to filter the document based on any condition, if you have not created indexing on the field(key) then it will check the condition in every document, so it will be impacted in the performance of the query. If we create indexing then MongoDB would use these indexes to limit the number of documents to search in the collection.

Note:- in MongoDB, every document has _id (ObjectID), which is automatically created when you create a Document and it has a 12 digit number with unique value.

divide the 12 digit Object ID

4-byte value representing the seconds since the Unix epoch (which will not run out of seconds until the year 2106)
3-byte machine identifier (usually derived from the MAC address),
2-byte process id.
3-byte counter, starting with a random value.

In MongoDB, Creating a index through createIndex() method

Syntax:-

 db.collectionName.createIndex({key:1})

Where a key is a document key.

Note:- You can create multiple indexing in a document.

Example:-

 db.employees.createIndex({department:1})

Output:-

Note:- Ok represent 1, it means index created successfully.

db.collectionName.getIndexes()

Example:-

db.employees.getIndexes()

Output:-

db.collectionName.dropIndex({key:1})

Example:-

db.employees.dropIndex({department:1})

Output:-