🍃

Mongo DB
INTRODUCTION TO MONGO
SQL vs NOSQL
MongoDB terminologies
JSON vs BSON
INSTALLATION
CRUD OPERATIONS
Insert Operation
Search Operations
Update Operations
Updating arrays and embedded Documents
Deletion Operations
Importing JSON in MongoDB
Mongo export
Comparison Operators
Cursors
Cursor methods
Logical Operators
Complex Expressions
Elements Operators
Projections
Embedded Documents
Indexes
Aggregation
MongoDB atlas
MongoDB Compass
MongoDB Drivers
Python

INTRODUCTION TO MONGO
MongoDB is a document database. It stores data in a type of JSON format
called BSON. Created by company called 10gen which is now known as
MongoDB, founded by Eliot Horowitz and Merriman in 2007

Mongo DB 1
 A record in MongoDB is a document, which is a data structure composed of key
value pairs similar to the structure of JSON objects

Records in a MongoDB database are called documents, and the field

values may include numbers, strings, booleans, arrays, or even nested
documents.

{
title: "Post Title 1",
body: "Body of post.",
category: "News",
likes: 1,
tags: ["news", "events"],
date: Date()
}

SQL vs NOSQL
SQL NOSQL

Data Structure: Document-oriented,

Data Structure: Tables with fixed
key-value pairs, wide-column stores, or
schema.
graphs. Redis.

Schema: Dynamic or schema-less,

Schema: Predefined, rigid structure.
allowing flexibility.

Scale: Vertical scaling (adding power to Scale: Horizontal scaling (adding more
a single server). servers to a distributed system).

Query Language: SQL (Structured Query Query Language: Varies; can be SQL-
Language). like or specialized query languages.

ACID Properties: Follows ACID ACID Properties: May relax ACID

properties for data integrity. properties for better performance.

Use Cases: Large-scale, rapidly evolving

Use Cases: Complex query-intensive data sets, and applications with changing
applications. data requirements.
Examples: MySQL, PostgreSQL, Oracle Examples: MongoDB, Cassandra,
CouchDB,

Scalability: SQL is vertically scalable; NoSQL is horizontally scalable.

Mongo DB 2
 Flexibility: SQL is rigid; NoSQL is flexible, suitable for evolving data models.

Complexity: SQL for complex queries and transactions; NoSQL is simpler

but may not handle complex queries as efficiently.

MongoDB terminologies
graph TD
id1[(Database)] --collections-->id3(students) & id4(Teache
id3 --> id31[document]
id4 --> id41[document]
id5 --> id51[document]

JSON vs BSON
In mongo dB, we write JSON format only but behind the scene data is stored in
BSON (binary json) format, Using BSON mongo dB can achieve higher read and
write speeds, reduce stroage requirements, improved data manipulation
capabilities

INSTALLATION
1. Download MongoDB:

Visit the MongoDB download page and select the appropriate version
for Windows.

download database tools

download mongo DB shell

Follow the installation instructions provided.

2. Install MongoDB:

Run the installer you downloaded.

Follow the setup wizard instructions.

Choose the Complete installation type, which installs MongoDB as a

service.

3. Start MongoDB:

Mongo DB 3
 MongoDB should start automatically after installation. If not, you can
start it manually by running the mongod command in the Command
Prompt.

4. Connect to MongoDB:

Open a new Command Prompt window.

Run the mongo command to connect to the MongoDB server.

CRUD OPERATIONS
To see all databases

test> show dbs;

To create database

test> use <database-name>;

To delete database

test> db.dropDatabase();

To see all collections

test> show collections;

To create new collections

test> db.createCollection('<collection-name>');

Mongo DB 4
 To delete a collection

test> db.<collection-name>.drop();

Insert Operation

To insert single document in the collection

student> db.collectionName.insertOne({
key1: value1,
key2: value2,
// Additional fields as needed
});

To insert many documents in the collections

student> db.collectionName.insertMany([
{
key1: value1,
key2: value2,
// Additional fields as needed
},
{
key1: value1,
key2: value2,
// Additional fields as needed
},
// Additional documents
]);

Search Operations

To read all documents in the collections

Mongo DB 5
 student> db.<collectionName>.find();

To find only the first document occurred in the list

student> db.<collectionName>.findOne({"name":"vinod"});

To search a specific Document in the collection

student> db.<collectionName>.find({ key: value });

Setting limit and skip in results of Find

student> db.<collectionName>.find().limit(5); // Limits the

student> db.<collectionName>.find().skip(5); // Skips the f

Update Operations

To update a existing document

db.<collectionName>.updateOne(
{ key: value },
{ $set: { updatedKey: updatedValue } }
);

To update multiple documents

db.<collectionName>.updateMany(
{ key: value },
{ $set: { updatedKey: updatedValue } }
);

Mongo DB 6
 Removing Fields

db.mycollection.updateMany(
{filter}, // Empty filter matches all documents
{ $unset: { fieldName: 1 } }
);

Rename Fields

db.mycollection.updateMany(
{filter}, // Empty filter matches all documents
{ $rename: { "oldFieldName": "newFieldName" } }
);

Updating arrays and embedded Documents

add an element to the array

db.collectionName.updateOne(
{ filter },
{ $push: { arrayfield: "Newelement" } }
);

Remove an element from the array

db.collectionName.updateOne(
{ filter },
{ $pull: { arrayfield: "value" } }
);

Update an element in the array

Mongo DB 7
 db.books.update(
{ _id: 1, "authors": "Author2" },
{ $set: { "authors.$": "UpdatedAuthor2" } }
);

Deletion Operations

To delete a single document

db.collectionName.deleteOne({ key: value });

To delete multiple documents

db.collectionName.deleteMany({ key: value });

Importing JSON in MongoDB

Open a terminal or command prompt and use the mongoimport command to
import the JSON file into MongoDB. The basic syntax is as follows:

mongoimport --db <databaseName> --collection <collectionName>

OR

mongoimport jsonfile.json -d <databaseName> -c <collectionName

The --jsonArray option simplifies the mongoimport process by indicating that the
input JSON file is a single array, where each element becomes a separate
document in the MongoDB collection. Use it for datasets structured as arrays of
objects.

Mongo export
To export data from MongoDB, you can use the mongoexport tool. This tool allows
you to export data from a collection into a JSON, CSV, or TSV file.

Mongo DB 8
 mongoexport --db <databaseName> --collection <collectionName>

mongoexport --db mydatabase --collection mycollection --type=c

mongoexport --db <databaseName> --collection <collectionName>

Comparison Operators
Equality

$eq : Matches values that are equal to a specified value.

db.collectionName.find({ field: { $eq: value } })

Inequality

db.collectionName.find({ field: { $ne: value } })

Greater Than

$gt : Matches values that are greater than a specified value.

db.collectionName.find({ field: { $gt: value } })

Greater than or Equal to

$gte : Matches values that are greater than or equal to a specified value.

db.collectionName.find({ field: { $gte: value } })

Less than

Mongo DB 9
 $lt : Matches values that are less than a specified value.

db.collectionName.find({ field: { $lt: value } })

Less than or Equal to

$lte : Matches values that are less than or equal to a specified value.

db.collectionName.find({ field: { $lte: value } })

IN

$in : Matches any of the values specified in an array.

db.collectionName.find({ field: { $in: [value1, value2] } })

Not IN

$nin : Matches none of the values specified in an array.

db.collectionName.find({ field: { $nin: [value1, value2] } })

Modulus

$mod : Performs a modulus operation on the field value and selects documents
with a specified remainder.

db.collectionName.find({ field: { $mod: [divisor, remainder]

Regualr Expression

$regex: Selects documents where the field matches a specified regular

expression pattern.

db.collectionName.find({ field: { $regex: /pattern/ } })

Mongo DB 10
 Cursors
In MongoDB, a cursor is a pointer to the result set of a query. When you query a
MongoDB collection, the result set can be quite large, and it might not fit
entirely in memory. To efficiently handle large result sets, MongoDB uses
cursors to retrieve a small batch of documents at a time.

Cursors in MongoDB provide a flexible and memory-efficient way to handle

large result sets while allowing you to process documents as needed.
Remember to close the cursor when you are done with it, to free up server
resources.

Cursor methods
next() Method:

The next() method retrieves the next document from the result set.

var cursor = db.collection.find();

var document = cursor.next();

forEach() Method:

The forEach() method applies a JavaScript function to each document

in the result set.

var cursor = db.collection.find();

cursor.forEach(function(doc) {
printjson(doc);
});

hasNext() Method:

The hasNext() method checks if there are more documents in the result
set.

var cursor = db.collection.find();

while (cursor.hasNext()) {
var document = cursor.next();

Mongo DB 11
 // Do something with the document
}

toArray() Method:

The toArray() method converts the cursor to an array, allowing you to

work with the entire result set in memory.

var cursor = db.collection.find();

var resultArray = cursor.toArray();

limit() Method:

The limit() method restricts the number of documents returned by the

cursor.

var cursor = db.collection.find().limit(10);

skip() Method:

The skip() method skips a specified number of documents and returns

the rest.

var cursor = db.collection.find().skip(5);

sort() Method:

The sort() method sorts the result set based on one or more fields.

1 for ascending order and -1 for descend

var cursor = db.collection.find().sort({ field: 1 });

count() Method:

The count() method returns the number of documents in the result set
without retrieving them.

var count = db.collection.find().count();

distinct() Method:

Mongo DB 12
 The distinct() method returns an array of distinct values for a specified
field.

var distinctValues = db.collection.distinct("fieldName"

Logical Operators
AND $and

db.collection.find({
$and: [
{ field1: value1 },
{ field2: value2 }
]
});

OR $or

db.collection.find({
$or: [
{ field1: value1 },
{ field2: value2 }
]
});

NOT $not

db.collection.find({
field: { $not: { $eq: value } }
});

Complex Expressions

Mongo DB 13
 The $expr operator in MongoDB is used to evaluate expressions within the
query language. It allows you to use aggregation expressions to compare
values in the same document during the query stage. This operator is
particularly useful when you need to compare fields within the same document
or perform more complex evaluations that go beyond the capabilities of regular
query operators.
The $expr operator in MongoDB is used to evaluate expressions within the
query language. It allows you to use aggregation expressions to compare
values in the same document during the query stage. This operator is
particularly useful when you need to compare fields within the same document
or perform more complex evaluations that go beyond the capabilities of regular
query operators.
Here's a basic example to illustrate the use of $expr :

db.sales.find({
$expr: {
$gt: ["$salesAmount", "$targetAmount"]
}
});

In this example, the query retrieves documents from the "sales" collection
where the value of the "salesAmount" field is greater than the value of the
"targetAmount" field within the same document.

Elements Operators
Equality ( $eq ) Operator:

Matches documents where the value of a field is equal to a specified value.

db.collection.find({ field: { $eq: value } });

Existence ( $exists ) Operator:

Matches documents where a specified field exists or does not exist.

Mongo DB 14
 // Documents where the "field" exists
db.collection.find({ field: { $exists: true } });

// Documents where the "field" does not exist

db.collection.find({ field: { $exists: false } });

Type ( $type ) Operator:

Matches documents where the value of a field is of a specified BSON data

type.

// Documents where the "field" is of type String (2)

db.collection.find({ field: { $type: 2 } });

Modulus ( $mod ) Operator:

Performs a modulus operation on the value of a field and selects

documents with a specified remainder.

// Documents where the value of "field" divided by 5 has a

remainder of 1
db.collection.find({ field: { $mod: [5, 1] } });

Array Operators (e.g., $size , $elemMatch ):

MongoDB provides various operators for working with arrays.

$size : Matches documents where the size of an array field is a specified

size.

// Documents where the size of the "field" array is 3

db.collection.find({ field: { $size: 3 } });

: Matches documents where at least one element in an array

$elemMatch

matches specified criteria.

Mongo DB 15
 // Documents where the "field" array has at least one el
ement greater than 10
db.collection.find({ field: { $elemMatch: { $gt: 10 } }
});

$alloperator is used as part of query expressions to match documents

where an array field contains all the specified values.

db.collection.find({ field: { $all: [value1, value2, ...]

Projections
projections refer to the mechanism of specifying which fields of a document
should be included or excluded in the result set of a query. Projections allow
you to shape the output of your queries by determining which fields are
returned and which are omitted.

To include specific fields in the result set, you specify the field names with a
value of 1 :

// Include only the "name" and "age" fields

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

for excluding a specific field

// Exclude the "password" field

db.collection.find({}, { password: 0 });

Embedded Documents
Query by Embedded Field:

// Find persons living in Cityville

db.people.find({ "address.city": "Cityville" });

Mongo DB 16
 Query by Multiple Embedded Fields:

// Find persons in CA with age greater than 25

db.people.find({ "address.state": "CA", age: { $gt: 25 }
});

Updating Embedded Documents:

// Update the zip code of John Doe's address

db.people.update(
{ name: "John Doe" },
{ $set: { "address.zip": "54321" } }
);

Adding New Embedded Documents

// Add a new person with an embedded address

db.people.insert({
name: "Alice Smith",
age: 25,
address: {
street: "456 Oak St",
city: "Townsville",
state: "NY",
zip: "67890"
}
});

Indexes
indexes are data structures that improve the speed of data retrieval operations
on a MongoDB database. Indexes are similar to the indexes found in books:

Mongo DB 17
 they provide a quick way to look up information based on the values of specific
fields. Without indexes, MongoDB would have to perform a collection scan,
which can be slow and resource-intensive, especially as the size of the
collection grows.

To create new Index

db.products.createIndex({field:1})
//1 for ascending order and -1 for descending order

To Get all the index

db.collection.getIndexes()

💡 _id is the default index

To delete all the indes

db.collection.dropIndex({field:1})
db.collection.dropIndex("index_name")

We can set to Unique:true

db.collection.createIndex({field:1}, {Unique:true})

Searching using index is faster than $regex searching

db.collection.createIndex({field:"text"})
db.products.find({field{$regex:"air"}}) //slower
db.collection.find( $text: {$search:"keyboard"}})

Mongo DB 18
 Aggregation
Aggregation in MongoDB refers to the process of transforming and
manipulating documents in a collection to produce computed results. The
aggregation framework is a powerful and flexible tool that enables you to
perform data transformations, group data, filter data, and compute
aggregations on documents. It is a pipeline-based framework that processes
documents through a sequence of stages, allowing you to perform complex
transformations on your data.

$match: Filters the documents based on specified criteria.

db.collection.aggregate([
{ $match: { field: value } }
]);

$group: Groups documents based on a specified key and

performs aggregations within each group.

db.collection.aggregate([
{ $group: { _id: "$field", count: { $sum: 1 } } }
]);

$project: Reshapes the documents, including or excluding

fields.

db.collection.aggregate([
{ $project: { newField: "$oldField", _id: 0 } }
]);

$sort: Sorts the documents based on specified fields.

db.collection.aggregate([
{ $sort: { field: 1 } }

Mongo DB 19
 ]);

$limit and $skip: Limits the number of documents in the

output or skips a specified number of documents.

db.collection.aggregate([
{ $limit: 10 },
{ $skip: 5 }
]);

$unwind: Deconstructs an array field, creating multiple

documents for each array element.

db.collection.aggregate([
{ $unwind: "$arrayField" }
]);

$lookup: Performs a left outer join with another collection.

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

Example of aggregation

Mongo DB 20
 db.orders.aggregate([
{
$lookup: {
from: "products",
localField: "productId",
foreignField: "_id",
as: "product"
}
},
{
$unwind: "$product"
},
{
$group: {
_id: "$product.category",
totalRevenue: { $sum: { $multiply: ["$quantity", "$prod
}
},
{
$sort: { totalRevenue: -1 }
}
]);

MongoDB atlas
MongoDB Atlas is a fully-managed, cloud-based database service by
MongoDB, Inc., offering a hassle-free way to deploy and scale MongoDB
databases on popular cloud platforms. It handles routine operational tasks,
such as backups, security, and scaling, allowing developers to focus on
building applications. With support for major cloud providers, robust security
features, automated backups, and real-time monitoring, MongoDB Atlas
provides an efficient and scalable solution for deploying MongoDB databases in
the cloud, suitable for a wide range of applications.

MongoDB Compass

Mongo DB 21
 MongoDB Compass is the official graphical user interface for MongoDB,
offering an intuitive visual environment to explore and interact with MongoDB
databases. With features like schema analysis, query building, index
management, and real-time performance monitoring, Compass simplifies
database tasks for both developers and non-developers. It provides a user-
friendly interface to visualize and edit data, build aggregation pipelines, and
connect seamlessly to MongoDB Atlas. Whether examining data structures,
executing queries, or managing security settings, MongoDB Compass
enhances the MongoDB experience through a graphical and accessible
interface.

MongoDB Drivers
MongoDB drivers are language-specific tools that facilitate communication
between applications and MongoDB databases. They offer a simplified
interface for developers to perform common database operations (e.g., CRUD
tasks), manage connections, handle data serialization, and ensure secure
interactions. These drivers, available for various programming languages,
abstract the complexities of interacting with MongoDB, allowing developers to
work with the database using familiar language-specific syntax and
conventions.

Python
PyMongo

Mongo DB 22