MongoDB is an open-source document-oriented database management system used for storing large amounts of data. MongoDB uses sets and documents instead of columns and cells, like in traditional database systems, which is why it is classified as a NoSQL database. In MongoDB, records are made up of key-value pairs, which have been the basic unit of data. Collections are the same as relational database tables since they include collections of documents and functions. MongoDB allows you to search by ranges, fields, queries, or regular expressions, and specific fields inside documents can be returned with the help of queries. MongoDB scales horizontally by distributing data across numerous MongoDB instances. It also may be distributed over various servers, balancing load and replicating data to keep the system running and avoid hardware failure.

Home
Blog
Data Science
Most Common MongoDB Commands for MongoDB Beginners

Most Common MongoDB Commands for MongoDB Beginners

Q: 2. What are the advantages of using MongoDB?

To begin with, MongoDB is a schema-free NoSQL database. When working with MongoDB, you do not have to worry about designing the database structure. It gives the fields in the documents a significant level of freedom. MongoDB is a database that stores heterogeneous data and offers excellent performance, availability, and scalability. It also efficiently supports Geospatial. MongoDB is document-oriented and stores information as BSON documents. It also enables multiple document ACID transitions, similar to MongoDB 4.0's string. It does not need SQL injection and is simple to connect with Hadoop Big Data.

Q: 3. How is MongoDB different from standard databases?

MongoDB is a document-oriented, non-relational database, whereas most traditional databases are relational databases. Moreover, MongoDB is ideal for storing hierarchical data, but traditional databases are not. MongoDB also has a dynamic schema. A standard database, on the other hand, has a preset schema. The CAP theorem, which is built on consistency, availability, and partition tolerance, lies at the heart of MongoDB. The ACID qualities of atomicity, consistency, isolation, and durability are the foundations of standard databases. Finally, MongoDB is substantially quicker than traditional databases in terms of speed. Furthermore, traditional databases are substantially slower than MongoDB.

By Rohit Sharma

Updated on Jun 16, 2023 | 10 min read | 7.0k views

Table of Contents

Logging with MongoDB

The following command applies to logging in with MongoDB.

mongo -u <username> -p <password> –authenticationDatabase <db_name>

Note: Users must have the right credentials and database name for access.

Create a Database and Selecting the Database to work with

In MongoDB, the ‘use’ command is the first step to create a new database.

Syntax:

use db_name

On execution, this command will create a new database for a specific name. In case there is a database with a specific name, then it will return with the existing database.

The same ‘use’ command is also used for selecting a database and start working with.

Example:

Suppose you are starting a new education project with the database ‘edudb’. Then the command would be:

>use edudb

Switched to db edudb

Read: MongoDB Real World Use Cases: Advantages & Top Companies

Check Current Database

You can also check the current database with the command db as:

>db

Edudb

You need to have at least one file or document in the database to show in the overall list. You can do this by using the insert command easily.

Syntax:

> db.file.insert({“name”:”classes”})

Show all current databases

You can use the following commands to check the present database with show dbs as:

>show dbs

local 0.53443GB

test 0.12332GB

edudb 0.02423GB

In MongoDB, the test is present as the default database. All the collections by default are stored in the test only.

You can use the MongoDB command interface to manage tasks related to non-CRUD operations. The interface empowers users to fetch precise information from the server, replicating current scenarios, and run specific map-reduce tasks.

There are also specific commands to run in the current and admin database.

For current database in MondDB, use the following db.runCommand():

db.runCommand( { <command> } )

For admin database, use the following db.adminCommand():

db. adminCommand ( { <command> } )

For Creating a Collection, the following command:

db.createCollection(“collectionName”);

For inserting a document in the Collection:

// For inserting a single document in the collection

db.<collectionName>.insert({field1: “value”, field2: “value”})

// For inserting multiple documents in the collection

db.<collectionName>.insert([{field1: “value1”}, {field1: “value2”}])

db.<collectionName>.insertMany([{field1: “value1”}, {field1: “value2”}])

Explore Our Software Development Free Courses

Fundamentals of Cloud Computing	JavaScript Basics from the scratch	Data Structures and Algorithms
Blockchain Technology	React for Beginners	Core Java Basics
Java	Node.js for Beginners	Advanced JavaScript

To Save and Update document

Here ‘save’ command can do both functions insert an entirely new document or update an existing document.

db.<collectionName>.save({“_id”: new ObjectId(“jhgsdjhgdsf”), field1: “value”, field2: “value”});

Note: If there is a matching document ID, then it updates; otherwise, a new document is then created.

Listing the Users, Roles, and Collections

These commands list the number of users, their roles, and collections.

// Command to list all the collections from the current database

show collections;

db.getCollectionNames();

// Command to all the users from the current database

show users;

db.getUsers();

// Command to list all the user roles

show roles

To Display Collection records

// Command to retrieve all records

db.<collectionName>.find();

// This command fetches the first 10 results;

db.<collectionName>.find().limit(10);

// This command retrieves the records by id

db.<collectionName>.find({“_id”: ObjectId(“someid”)});

// This command fetches the value from a particular collection attribute with an object and assigned value of 0 or 1.

db.<collectionName>.find({“_id”: ObjectId(“someid”)}, {field1: 1, field2: 1});

db.<collectionName>.find({“_id”: ObjectId(“someid”)}, {field1: 0}); // Exclude field1

// This command checks the Collection count in a database

db.<collectionName>.count();

Liverpool John Moores University

MS in Data Science

Dual Credentials

Master's Degree17 Months

IIIT Bangalore

Post Graduate Certificate in Data Science & AI (Executive)

Placement Assistance

Certification8-8.5 Months

Explore our Popular Software Engineering Courses

Master of Science in Computer Science from LJMU & IIITB	Caltech CTME Cybersecurity Certificate Program
Full Stack Development Bootcamp	PG Program in Blockchain
Executive PG Program in Full Stack Development
Software Engineering Courses

For Administrative Commands

This command allows information about collection details with total size, storage, and multiple statistics.

// This command retrieves the collection statistics

db.<collectionName>.stats()

db.printCollectionStats()

// // This command retrieves the Latency statistics for reading and writes and a specific number of operations

db.<collectionName>.latencyStats()

// This command retrieves specific collection size for indexes and data

db.<collectionName>.dataSize() // fetches the Size of the collection

db.<collectionName>.storageSize() // fetches the total size of document stored

db.<collectionName>.totalSize() // fetches the total size in bytes for both collection data and indexes

db.<collectionName>.totalIndexSize() // fetches the total size of all indexes in the collection

For logging out from the database:

db.logout()

There are different types of commands that you can use in MongoDB, starting with:

User commands

Database Operations

1. User Commands

Aggregation Commands

Name	Description
aggregate	Command to perform aggregation tasks in a group.
count	Command to count the specific number of documents.
distinct	Command to display distinct value for a specific key in a collection.
mapReduce	Command to perform map-reduce task aggregation in large data sets.

Geospatial Commands

Name	Description
geoSearch	A command that performs a geospatial query through MongoDB haystack index function.

Query and Write operations commands

Name	Description
delete	Command to delete one or multiple documents.
find	Command to select single or multiple documents in a view.
insert	Command to insert one or multiple documents in a view.
update	Command to update one or multiple documents.

Query Plan Cache Commands

Name	Description
planCacheClear	Command to remove cached query plans from a collection.
planCacheClearFilters	Command that clears index filters from a collection.
planCacheListFilters	Command that lists index filters from a collection.
planCacheSetFilter	Command that sets an index filter from a collection.

upGrad’s Exclusive Software Development Webinar for you –

SAAS Business – What is So Different?

2. Database Operations

Authentication Problems

Name	Description
authenticate	A command that starts an authenticated session after verifying a username and password.
getnonce	Command to generate a one-time password for authentication.
logout	Command to terminate the given authenticated session.

User Management Commands

Name	Description
createUser	Command to create a new user.
dropUser	Command to remove a specific user.
updateUser	Command to update specific user data.
usersInfo	Command to retrieve information from a specific single or multiple users.

Role Management Commands

Name	Description
createRole	Command to build a specific user role and privilege.
dropRole	Command to delete a specific user-defined role from the database.
updateRole	Command that updates a specific user-defined role.

Replication Commands

Name	Description
applyOps	A command that adds oplog entries with the present data set.
isMaster	A command that displays information for the specific user in the present replica set to check if it is the master or not.
replSetInitiate	Command that initializes a specific new replica set.

Sharding Commands

Name	Description
addShard	A command that adds a new shard or sharded cluster.
listShards	A command that returns a list of pre-configured shards.
removeShard	A command that removes the particular shard from the cluster.

Session Commands

Name	Description
abortTransaction	Command to abort the transaction.
endSessions	Command to expire sessions before the timeout.
killAllSessions	Command to kill all sessions
refreshSessions	Command to refresh idle sessions.
startSession	Command to start a new session.

Administrative Commands

Name	Description
clean	A command that represents an internal namespace.
create	Command to create a collection or a specific view.
drop	Command to remove a specific collection from the current database.
reIndex	Command that rebuilds all indexes for a particular collection.
shutdown	Command to shut down the mongos or mongod process.

Free Monitoring Commands

Name	Description
setFreeMonitoring	It allows users to enable or disable free monitoring within the runtime.

Auditing Commands

Name	Description
logApplicationMessage	Commands add or post a customized message with the current audit log.

Command Responses

On every command execution, MongoDB retrieves a response with a specific field:

Field	Description
ok	An indication that command was a success (1) or a failure (0).
operationtime	This represents the specific time for performing operations in MongoDB with a timestamp from the oplog entry. In case the operation does not operate, then it does not generate any oplog entry. Then the operation time returns; local: from the most recent entry through the oplog. And for a majority and linearizable reads, the timestamp from the recent majority-acknowledged entry through the oplog.
$clusterTime	That defines the logical time for ordering a specific operation.

Checkout: CRUD Operations in MongoDB

In-Demand Software Development Skills

JavaScript Courses	Core Java Courses	Data Structures Courses
Node.js Courses	SQL Courses	Full stack development Courses
NFT Courses	DevOps Courses	Big Data Courses
React.js Courses	Cyber Security Courses	Cloud Computing Courses
Database Design Courses	Python Courses	Cryptocurrency Courses

Text Search

To look for particular words or phrases within a collection, utilise text search. The text search command is as follows:

db.collection_name.find({ $text: { $search: “search_query” } })

Geospatial Queries

Data searches based on location are done via geospatial queries. The geospatial queries $near and $geoWithin are supported by Mongo shell. The following is the command for geographical queries:

db.collection_name.find({ location_field: { $near: { $geometry: { type: “Point”, coordinates: [longitude, latitude] }, $maxDistance: distance_in_meters } } })

Aggregation

Data within a collection can be subjected to operations like grouping, counting, and averaging using an aggregate. The aggregate command is as follows:

db.collection_name.aggregate([ { $match: { condition } }, { $group: { _id: “$field_to_group_by”, result_field: { $operation: “$field_to_operate_on” } } } ])

Database and Collection Operations

The creation, modification, and deletion of databases and collections are handled through database and collection operations. The following commands are used to create a collection in MongoDB and database operations:

use database_name

db.createCollection(“collection_name”)

db.collection_name.insert(document)

db.collection_name.update({ condition }, { $set: { field: value } })

db.collection_name.remove({ condition })

Array Operators

When working with arrays in a collection, array operators are used. Several array operators, including $push, $pop, and $pull, are supported by MongoDB. The following are the commands for array operators:

db.collection_name.update({ condition }, { $push: { array_field: value_to_add } })

db.collection_name.update({ condition }, { $pop: { array_field: 1 } })

db.collection_name.update({ condition }, { $pull: { array_field: value_to_remove } })

Aggregation Framework

Data within a collection can be subjected to complicated operations using the Aggregation Framework, such as merging different collections and grouping data. The Aggregation Framework command is as follows:

db.collection_name.aggregate([ { $lookup: { from: “other_collection”, localField: “field_in_current_collection”, foreignField: “field_in_other_collection”, as: “new_field_name” } }, { $unwind: “$new_field_name” }, { $group: { _id: “$field_to_group_by”, result_field: { $operation: “$field_to_operate_on” } } } ])

Indexing

The performance of queries on a collection is enhanced by indexing. MongoDB supports a variety of index types, including single field, compound, and text indexes. These are the indexing commands:

db.collection_name.createIndex({ field_name: index_type })

db.collection_name.getIndexes()

db.collection_name.dropIndex({ field_name: index_type })

Map-Reduce

The Map-Reduce algorithm processes large amounts of data inside a collection to get aggregated results. Here is the Map-Reduce command:

db.collection_name.mapReduce(map_function, reduce_function, { out: “output_collection_name” })

Update Operators

Use update operators to modify a collection’s data. MongoDB supports a number of update operators, including $set, $inc, and $push. The update operator commands are as follows:

db.collection_name.update({ condition }, { $set: { field: new_value } })

db.collection_name.update({ condition }, { $inc: { field: increment_value } })