All of us do not have equal

talent. But, all of us have an

equal opportunity to develop
our talents.
A.P.J. Abdul Kalam

Database Technologies -
MongoDB
Enterprise primaryDB> config.set("editor", "notepad+ iet
+")
 Class Room

Session 1
 Big Data?
Big data is a term that describes the large volume of data –
both structured and unstructured.

What is Big Data?

Big Data is also data but with a huge size. Big Data is a term used to
describe a collection of data that is huge in size and yet growing with time.
In short such data is so large and complex that none of the traditional data
management tools are able to store it or process it efficiently.

Characteristics Of Big Data

Big data is often characterized by the 3Vs: the extreme VOLUME
of data, the wide VARIETY of data and the VELOCITY at which
the data must be processed.
 NoSQL
NoSQL database are primarily called as non-SQL or non-relational database. MongoDB is
Scalable (able to be changed in size or scale), open-source, high-perform,
document-oriented database.

Remember:
• Horizontal scaling means that you scale by adding more machines into your pool of resources.
• Vertical scaling means that you scale by adding more power (CPU, RAM) to an existing machine.
why NoSQL
 when to use NoSQL
When should NoSQL be used:
• When huge amount of data need to be stored and retrieved .
• The relationship between the data you store is not that important
• The data changing over time and is not structured.
• Support of Constraints and Joins is not required at database level.
• The data is growing continuously and you need to scale the database regular to handle the
data.
Remember:
• Data Persistence on Server-Side via NoSQL.
• Does not use SQL-like query language.
• Longer persistence
• Store massive amounts of data.
• Systems can be scaled.
• High availability.
• Semi-structured data.
• Support for numerous concurrent connections.
• Indexing of records for faster retrieval
NoSQL Categories
 NoSQL Categories
There are 4 basic types of NoSQL databases.
Key-value stores, or key-value databases, implement a simple data model
that pairs a unique key with an associated value.
Key-value stores e.g.
• Redis, Cassandra

Wide-column stores organize data tables as columns instead of as rows.

Column-oriented e.g.
• hBase

Document databases, also called document stores, store semi-structured

data and descriptions of that data in document format.
Document
e.g.
oriented
• MongoDB, CouchDB

Graph data stores organize data as nodes.

Graph e.g.
• Neo4j
 NoSQL Categories

Column-oriented Graph
An object is an unordered set of name/value pairs.

An array is an ordered collection of values.

 SQL vs NoSQL Database

Relational databases are commonly referred to as SQL databases because they use
SQL (structured query language) as a way of storing and querying the data.

Difference:
• NoSQL databases are document based, key-value pairs, or wide-column stores. This
means that SQL databases represent data in form of tables which consists of n
number of rows of data whereas NoSQL databases are the collection of key-value
pair, documents, or wide-column stores which do not have standard schema
definitions.
• SQL databases have predefined schema whereas NoSQL databases have dynamic
schema for unstructured data.
• SQL databases are vertically scalable whereas the NoSQL databases are horizontally
scalable.
• SQL databases uses SQL ( structured query language ) for defining and
manipulating the data. In NoSQL database, queries are focused on collection of
documents.
 Types of Data
Structured Semi-Structured Unstructured

MongoDB stores documents (objects) in a format called BSON.

BSON is a binary serialization of JSON
 Types of Data
• Structured
The data that can be stored and processed in a fixed format is called as Structured Data. Data
stored in a relational database management system (RDBMS) is one example of ‘structured’
data. It is easy to process structured data as it has a fixed schema. Structured Query
Language (SQL) is often used to manage such kind of Data.

• Semi-Structured
Semi-Structured Data is a type of data which does not have a formal structure of a data
model, i.e. a table definition in a relational DBMS, XML files or JSON documents are
examples of semi-structured data.

• Unstructured
The data which have unknown form and cannot be stored in RDBMS and cannot be analyzed
unless it is transformed into a structured format is called as unstructured data. Text Files and
multimedia contents like images, audios, videos are example of unstructured data.
 MongoDB
MongoDB is a cross-platform document-oriented database program. Classified as a
NoSQL database.
Remember:
• MongoDB documents are similar to JSON (key/fields and value pairs) objects.
• The values of fields may include other documents, arrays, or an arrays of documents.

Core MongoDB Operations (CRUD), stands for create, read, update,

and delete.
SQL/MongoDB Terms:
 MongoDB
MongoDB stores data as BSON documents. BSON is a binary representation
of JSON documents.

JSON (JavaScript Object Notation) is a lightweight data-interchange format.

It is easy for humans to read and write.
* MongoDB does not support duplicate
field names

document
MongoDB stores data as BSON documents. BSON is a binary representation of
JSON documents.
document
 document
MongoDB documents are composed of field-and-value pairs. The value of a
field can be any of the BSON data types, including other documents, arrays,
and arrays of documents.

The field name _id is reserved for use as a primary key; its value must be
unique in the collection, is immutable, and may be of any type other than an
array.

{ The primary key _id is automatically

field1: value1, added, if _id field is not specified.
field2: value2,
field3: value3,
...
fieldN: valueN
}

Note:
• MongoDB does not support duplicate field names.
 db
In the mongo shell, db is the variable that references the current database. The
variable is automatically set to the default database test or is set when you use
the use <db_name> to switch current database.
 MongoDB Redis MySQL Oracle
Database
mongod redis-server mysqld oracle
Server
Database
mongo redis-cli mysql sqlplus
Client

start db server
 start server and client
Tostart MongoDB server, execute mongod.exe.
Note: Always give --dbpath in ""
•The --dbpath option points to your database directory.
•The --bind_ip_all option : bind to all ip addresses.
•The --bind_ip arg option : comma separated list of ip addresses to listen on, localhost
by default.
--bind_ip <hostnames |
ipaddresses>
mongod --dbpath "c:\database" --bind_ip_all --journal
mongod --dbpath "c:\database" --bind_ip stp10 --journal
mongod --dbpath "c:\database" --bind_ip 192.168.100.20 --journal
mongod --dbpath="c:\database" --bind_ip=192.168.100.20 –journal
mongod –auth --dbpath="c:\database" --bind_ip=192.168.100.20 --journal
mongod --storageEngine inMemory --dbpath "d:\tmp" --bind_ip 192.168.100.20
To start MongoDB client, execute mongo.exe.
must be empty
mongo "192.168.100.20:27017/db1"
folder
mongo --host "192.168.100.20" --port "27017"
mongo --host "192.168.100.20" --port "27017" primaryDB
mongo --host="192.168.100.20" --port="27017" primaryDB
mongo --host="192.168.100.20" --port="27017" –u user01 -p user01 --
authenticationDatabase primaryDB
• db.version(); # version number
• db.getMongo(); # connection to 192.168.100.20:27017
• db.hostInfo(); # Returns a document with information about the mongoDB is runs on.
• db.stats(); # Returns DB status
• getHostName(); # stp5

comparison operator
 comparison operator

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

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

Matches values that are greater than or equal to a specified
$gte
value.
$lt Matches values that are less than a specified value.
Matches values that are less than or equal to a specified
$lte
value.
$ne Matches all values that are not equal to a specified value.

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

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

 comparison operator
$eq $ne
{ field: { $eq: value } } { field: { $ne: value } }

$gt $gte
{ field: { $gt: value } } { field: { $gte: value } }

$lt $lte
{ field: { $lt: value } } { field: { $lte: value } }

$in
{ field: { $in: [ <value1>, <value2>, ..., <valueN> ] } }

$nin
{ field: { $nin: [ <value1>, <value2>, ..., <valueN> ] } }
logical operator
 logical operator

Joins query clauses with a logical OR returns all documents

$or that
match the conditions of either clause.
Joins query clauses with a logical AND returns all documents
$and that
match the conditions of both clauses.
Inverts the effect of a query expression and returns
$not documents that
do not match the query expression.

{ $or: [ { <expr1> }, { <expr2> }, ..., { <exprN> } ] }

{ $and: [ { <expr1> }, { <expr2> }, ..., { <exprN> } ] }

{ field: { $not: { <operator-expression> } } }

• db.emp.find( { $or:[ { job: 'manager' }, { job: 'salesman' } ], $and:

[ { sal: {$gt:3000 }} ] }, { _id: false, ename: true, job: true, sal: true
} );
 logical operator
$or
{ $or: [ { <expr1> }, { <expr2> }, ... , { <exprN> } ] }

• db.emp.find({$or: [{job: 'manager'}, {job: 'salesman'}]})

$and
{ $and: [ { <expr1> }, { <expr2> }, ... , { <exprN> } ] }

• db.emp.find({$and: [{job:'manager'}, {sal:3400}]})

$not
{ field: { $not: { <operator-expression> } } }

• db.emp.find({ job: {$not: {$eq: 'manager'}}})

 ObjectId()
The ObjectId class is the default primary key for a MongoDB
document and is usually found in the _id field in an inserted
document.

The _id field must have a unique value. You can think of the
_id field as the document’s primary key.
 ObjectId()
MongoDB uses ObjectIds as the default value of _id field of each
document, which is auto generated while the creation of any document.

ObjectId()

• x = ObjectId()
 show databases
Print a list of all available databases.
 show database
Print a list of all databases on the server.

show { dbs | databases }

• show dbs
• show databases # Returns: all database name.

db.getName()
• db
• db.getName() # Returns: the current database name.
To access an element of an array by the zero-based index position,
concatenate the array name with the dot (.) and zero-based index
position, and enclose in quotes

use database
Switch current database to <db>. The mongo shell variable db is set
to the current database.
 use database
Switch current database to <db>. The mongo shell variable db is set to the
current database.

use <db>

• use db1
db.dropDatabase()
 db.dropDatabase()
Removes the current database, deleting the associated data files.

db.dropDatabase()

• use db1
• db.dropDatabase()

Infoway Technologies, 3rd Floor Commerce Centre, Rambaug Colony, Paud

If not working then do changes in
my.ini file.
secure_file_priv = ""
• SELECT * FROM emp INTO OUTFILE "d:/emp.csv" FIELDS
TERMINATED BY ',';

mongoimport
mongoimport tool imports content from an Extended JSON, CSV,
or TSV export created by mongoexport, or another third-party export
tool.
 mongoimport - JSON
The mongoimport tool imports content from an Extended JSON, CSV, or
TSV export created by mongoexport.

mongoimport < --host > < --port > < --db > < --collection > <
--type > < --file > < --fields "Field-List" > < --mode
{ insert | upsert | merge } > < --jsonArray > < --drop >

< --jsonArray > # if the documents are in array i.e. in [] brackets

< --drop > # drops the collection if exists

• C:\> mongoimport --host 192.168.0.3 --port 27017 --db db1 --collection

emp --type json --file "d:\emp.json"
• C:\> mongoimport --host 192.168.0.6 --port 27017 --db db1 --collection
movies --type json --file "d:\movies.json" --jsonArray --drop
 mongoimport - CSV
The mongoimport tool imports content from an Extended JSON, CSV, or
TSV export created by mongoexport.

mongoimport < --host > < --port > < --db > < --collection > < --type >
< --file > < --fields "<field1>[,<field2>]*" < --headerline > > < --
useArrayIndexFields >

• C:\> mongoimport --host 192.168.100.20 --port 27017 --db db1 --collection emp --type csv
--file d:\emp.csv --headerline
• C:\> mongoimport --host 192.168.100.20 --port 27017 --db db1 --collection emp --type csv
--file d:\emp.csv --fields
"EMPNO,ENAME,JOB,MGR,HIREDATE,SAL,COMM,DEPTNO,BONUSID,USERNAME,PWD"
• C:\> mongoimport --db db1 --collection o --type csv --file d:\emp.csv --fields
"EMPNO.int(32),ENAME.string(),JOB.string(),MGR.int32(),HIREDATE.date(2006-01-
02),SAL.int32(),COMM.int32(),DEPTNO.int32(),BONUSID.int32(),USERNAME.string(),PWD.string()"

Note:
• There should be no blank space in the field list.
e.g.
_id, ename, salary #this is an error
 mongoimport - CSV
The mongoimport tool imports content from an Extended JSON, CSV, or
TSV export created by mongoexport.

mongoimport < --host > < --port > < --db > < --collection > < --type >
< --file > < --fields "<field1>[,<field2>]*" < --headerline > > < --
useArrayIndexFields >

_id,course,duration,modules.0,modules.1,modules.2,
modules.3
1,course1,6 months,c++,database,java,.net
2,course2,6 months,c++,database,python,R
3,course3,6 months,c++,database,awp,.net

• C:\> mongoimport --host 192.168.100.20 --port 27017 --db db1 --collection

course --type csv --file d:\course.csv --headerline --useArrayIndexFields
 mongoexport
mongoexport is a utility that produces a JSON or CSV export of
data stored in a MongoDB instance.
 mongoexport
mongoexport is a utility that produces a JSON or CSV export of data stored
in a MongoDB instance..

mongoexport < --host > < --port > < --db > < --collection > < --type >
< --file > < --out >

• C:\> mongoexport --host 192.168.0.6 --port 27017 --db db1 --collection emp --
type JSON --out "d:\emp.json"
• C:\> mongoexport --host 192.168.0.6 --port 27017 --db db1 --collection emp --
type JSON --out "d:\emp.json" --fields "empno,ename,job"
• C:\> mongoexport --host 192.168.0.6 --port 27017 --db db1 --collection emp --
type CSV --out "d:\emp.csv" --fields "empno,ename,job"

Note:
• there should be no space in the field list.
e.g.
_id, ename, salary #this is an error
 new Date()
TODO
 new Date()
MongoDB uses ObjectIds as the default value of _id field of each document,
which is auto generated while the creation of any document.

var variable_name = new Date()

• x = Date()
 db.getCollectionNames()
Returns an array containing the names of all collections and views in
the current database.
 db.getCollectionNames()
getCollectionNames() returns an array containing the names of all
collections in the current database.

show collection
db.getCollectionNames()

• show collections
• db.getCollectionNames();
 db.createCollection()
Creates a new collection or view.
 db.createCollection()
Capped collections have maximum size or document counts that prevent
them from growing beyond maximum thresholds. All capped collections
must specify a maximum size and may also specify a maximum document
count. MongoDB removes older documents if a collection reaches the
maximum size limit before it reaches the maximum document count.

db.createCollection(name, { options1, options2, ... })

The options document contains the following fields:

• capped : boolean
• size : number
• max : number

• db.createCollection("log");
• db.createCollection("log", { capped: true, size: 1, max: 2}); //
This command creates a collection named log with a maximum size of 1 byte and a maximum
of 2 documents.
 db.collection.isCapped()
Returns true if the collection is a capped collection, otherwise
returns false.
 db.collection.isCapped()
isCapped() returns true if the collection is a capped collection, otherwise
returns false.
db.collection.isCapped()

• db.log.isCapped();
 db.getCollection()
Returns a collection or a view object that is in the DB.
 db.getCollection()
TODO

db.getCollection('name')

• db.getCollection('emp').find();

• const auth = db.getCollection("author")

const doc = {
usrName : "John Doe",
usrDept : "Sales",
usrTitle : "Executive Account Manager",
authLevel : 4,
authDept : [ "Sales", "Customers"]
}

auth.insertOne( doc )
 db.getSiblingDB()
To access another database without switching databases.
 db.getSiblingDB()
Used to return another database without modifying the db variable in the
shell environment.

db.getSiblingDB(<database>)

• db.getSiblingDB('db1').getCollectionNames();
db.collection.renameCollect
ion()
Renames a collection.
 db.collection.renameCollection()
TODO

db.collection.renameCollection(target, dropTarget)

• db.emp.renameCollection('employee', false);

dropTarget : If true, mongod drops the target of renameCollection prior to

renaming the collection. The default value is false.
 db.collection.drop()
Removes a collection or view from the database. The method also
removes any indexes associated with the dropped collection.
 db.collection.drop()
drop() removes a collection or view from the database. The method also
removes any indexes associated with the dropped collection.

db.collection.drop(<options>)

• db.emp.drop();
Method Embedded Field Specification
.pretty() For fields in an embedded documents, you can specify the field
using either:
dot notation; e.g. "field.nestedfield": <value>
nested form; e.g. { field: { nestedfield: <value> } }
For query on array elements:
array; e.g. '<array>.<index>'

db.collection.find()
The find() method always returns the _id field unless you specify _id:
0/false to suppress the field.

By default, mongo prints the first 20 documents. The mongo shell

will prompt the user to Type "it" to continue iterating the next 20
results.
Enterprise primaryDB> config.set("displayBatchSize", 3)

• db.emp.find( { }, { _id: false, sal: true, Per : { $multiply: ['$sal', .05 ] },

NewSalary: { $add: ['$sal', { $multiply: [ '$sal', .05 ] } ] } } )
 db.collection.find()
TODO

db['collection'].find({ query }, { projection })

db.collection.find({ query }, { projection })
db.getCollection('name').find({ query }, { projection })

query: Specifies selection filter using query operators. To return all documents in a collection, omit
this parameter or pass an empty document ({}).
{ "<Field Name>": { "<Comparison Operator>": <Comparison Value> } }

projection: Specifies the fields to return in the documents that match the query filter. To return all
fields in the matching documents, omit this parameter.
{ "<Field Name>": <Boolean Value> } }

• 1 or true to include the field in the return documents. Non-zero integers are also
treated as true.
• 0 or false to exclude the field.
 db.collection.find()
TODO '<array>.<in
dex>'
db['collection'].find({ query }, { projection })
db.collection.find({ query }, { projection })
db.getCollection('name').find({ query }, { projection })

• db.emp.find();
• db ['emp'].find ()
• db.getCollection('emp').find();
• db.getSiblingDB('db1').getCollection('emp').find();
• db.emp.find({job: 'manager'})
• db.emp.find({}, {ename: true, job: true});
• db.emp.find({sal:{ $gt: 4 }})
• db.emp.find({job: 'manager'}, {ename: true, job: true})
• db.emp.find({job: 'manager'}, {_id: false, ename: true, job: true})
 db.collection.find()
TODO '<array>.<in
dex>'
db['collection'].find({ query }, { projection })
db.collection.find({ query }, { projection })
db.getCollection('name').find({ query }, { projection })

• const query1 = { "job": "manager" };

• const query2 = { "sal": { $gt: 6000, $lt: 6500 } };
• const projection = { "_id" : false, "ename": true, "job": true, "sal":
true , "address": true };

• db.emp.find( query1, projection )

• db.emp.find( query2, projection )

TODO

delete < variable_name >

• delete query1
 pattern matching with like in
db.collection.find()
TODO

• db.movies.find({movie_title: /z/}, {_id:false, movie_title:true});

• db.movies.find({movie_title: /^z/}, {_id:false, movie_title:true});
• db.movies.find({movie_title: /z$/}, {_id:false, movie_title:true});
• db.movies.aggregate({ $match:{movie_title: /z$/}}, {$project:{_id:false,
movie_title:true}});
 db.collection.find()[<index_number>]
TODO

db['collection'].find({ query }, { projection }) [<index> [.field] ]

db.collection.find({ query }, { projection }) [<index> [.field] ]
db.getCollection('name').find({ query }, { projection }) [<index> [.field] ]

• db.emp.find()[0];
• db.emp.find()[0].ename;
• db.getCollection('emp').find() [0];
• db.emp.find()[db.emp.find().count()-1]
 cursor with db.collection.find()
In the mongo shell, if the returned cursor is not assigned to a variable
using the var keyword, the cursor is automatically iterated to access up to
the first 20 documents that match the query.

var variable_name = db.collection.find({ query }, { projection })

The find() method returns a cursor.

var x = db['emp'].find()
x.forEach(printjson)
 sort
Specifies the order in which the query returns matching documents.
You must apply sort() to the cursor before retrieving any documents
from the database.
 db.collection.find().sort({ })
sort() specifies the order in which the query returns matching documents.
You must apply sort() to the cursor before retrieving any documents from
the database.
cursor.sort({ field: value })
db['collection'].find({ query }, { projection }).sort({ field: value })
db.collection.find({ query }, { projection }).sort({ field: value })

Specify in the sort parameter

• 1 to specify an ascending sort.
• -1 to specify an descending sort.

• db['emp'].find({}, {ename: true}).sort({ename: 1});

• db['emp'].find({}, {ename: true}).sort({ename: -1});
 limit
limit() method on a cursor to specify the maximum number of
documents the cursor will return.
A limit() value of 0 (i.e. db.collection.find().limit()
limit(0)) is equivalent to
setting no limit.
limit() method specify the maximum number of documents the cursor will
return.

cursor.limit(<number>)
db['collection'].find({ query }, { projection }).limit(<number>)
db.collection.find({ query }, { projection }).limit(<number>)

• db['emp'].find({}, { ename: true }).limit(0);# all documents

• db['emp'].find({}, { ename: true }).limit(2);
 skip
skip() method on a cursor to control where MongoDB begins
returning results.
 db.collection.find().skip()
skip() method is used for skipping the given number of documents in the
Query result.

cursor.skip(<offset_number>)
db['collection'].find({ query }, { projection }).skip(<offset_number>)
db.collection.find({ query }, { projection }).skip( < offset_number > )

• db.emp.find().skip(4);
• db.emp.find().skip(db.emp.countDocuments({}) - 1);
 count
Counts the number of documents referenced by a cursor. Append the
count() method to a find() query to return the number of matching
documents. The operation does not perform the query but instead
counts the results that would be returned by the query.
 db.collection.find().count()
count() counts the number of documents referenced by a cursor. Append
the count() method to a find() query to return the number of matching
documents. The operation does not perform the query but instead counts
the results that would be returned by the query.

cursor.count()
db['collection'].find({ query }).count()
db.collection.find({ query }).count()

• db.emp.find().count();
• db.emp.find({job: 'manager'}).count();
 db.collection.distinct()
Finds the distinct values for a specified field across a single
collection or view and returns the results in an array.
 db.collection.distinct()
distinct() finds the distinct values for a specified field across a single
collection or view and returns the results in an array.

db.collection.distinct("field", { query }, { options })

• db.emp.distinct("job")
• db.emp.distinct("job", { sal: { $gt: 5000 } } )

var x = db.emp.find()[10]
for (i in x) {
print(i)
}
db.collection.count[Docume
TODO nts]()
 db.collection.count[Documents]()
countDocuments() returns the count of documents that match the query
for a collection

db.collection.count[Documents]({ query }, { options })

Field Description

limit Optional. The maximum number of documents to count.

skip Optional. The number of documents to skip before counting.

• db.emp.count({});
• db.emp.countDocuments({});
• db.emp.countDocuments({job: 'manager'});
• db.emp.countDocuments({job: 'salesman'}, {skip: 1, limit: 3});
 findOne
find() method always returns the _id field unless you specify _id:
0/false to suppress the field.
 db.collection.findOne()
findOne() returns one document that satisfies the specified query criteria on
the collection. If multiple documents satisfy the query, this method returns
the first document according to the order in which order the documents are
stored in the disk. If no document satisfies the query, the method returns
null.
db['collection'].findOne({ query } , { projection })
db.collection.findOne({ query } , { projection })

• db.emp.findOne();
• db.emp.findOne({ job: 'manager' });
• If the document does not contain an _id field, then the save() method
calls the insert() method. During the operation, the mongo shell will
create an ObjectId and assign it to the _id field.
• If the document contains an _id field, then the save() method is
equivalent to an update with the upsert option set to true and the
query predicate on the _id field.

db.collection.save()
Updates an existing document or inserts a new document, depending
on its document parameter.
 db.collection.save()
save() UPDATES an existing document or INSERTS a new document,
depending on its document parameter.

db.collection.save({ document })

• db.x.save({_id: 10, firstName: 'neel', sal: 5000, color:

['blue', 'black' ], size: ['small', 'medium', 'large', 'xx-
large' ] })
 db.collection.insert()
Inserts a document or documents into a collection.
 db.collection.insert() or db.collection.insert([])
insert() inserts a single-document or multiple-documents into a
collection.

db.collection.insert({<document>})
db.collection.insert([{<document 1>} , {<document 2>}, ... ])

• db.x.insert({})
• db.x.insert({ ename: 'ram', job: 'programmer ', salary:
42000 })
• db.x.insert([ { ename: 'sham'} , { ename: 'y' } ]) #
for multiple documents.

• const doc1 = { "name": "basketball", "category": "sports", "quantity":

20, "reviews": [] };
• const doc2 = { "name": "football", "category": "sports", "quantity":
30, "reviews": [] };
• db.x.insert([ doc1, doc2 ])
db.collection.insertOne() &
db.collection.insertMany()
Inserts a document into a collection.
Inserts multiple documents into a collection.
 db.collection.insertOne() &
db.collection.insertMany([])
insertOne() inserts a single document into a collection.
insertMany() inserts a document or multiple documents into a collection.

db.collection.insertOne({<document>})
db.collection.insertMany([{<document 1>} , {<document 2>}, ... ])

• db.emp.insertOne({ ename: 'ram', job: 'programmer', salary: 2000 })

• db.emp.insertMany([ { ename: 'sham', salary: 2000}, { ename : 'raj', job:
'programmer' } ])

• const doc1 = { "name": "basketball", "category": "sports", "quantity": 20,

"reviews": [] };
• const doc2 = { "name": "football", "category": "sports", "quantity": 30,
"reviews": [] };
• db.x.insertMany([ doc1, doc2 ])
 javascript object
TODO
 javascript object
Inserts a document or documents into a collection using javascript object.

var obj = {}
> var doc = {}; # JavaScript object
> doc.title = "MongoDB Tutorial"
> doc.url = "http://mongodb.org"
> doc.comment = "Good tutorial video"
> doc.tags = ['tutorial', 'noSQL']
> doc.saveondate = new Date ()
> doc.meta = {} # object within doc object{}
> doc.meta.browser = 'Google Chrome'
> doc.meta.os = 'Microsoft Windows7'
> doc.meta.mongodbversion = '2.4.0.0'
> doc
> db.book.insert(doc);

> doc -> will print entire document.

> doc.Title -> will print only Title from document.
> print(doc) -> will print -> [object Object].
> print(doc.Title) -> will print only Title from document.
After executing a file with load(), you may reference any
functions or variables defined the file from the mongo shell
environment.

load ("app.js")
Loads and runs a JavaScript file into the current shell environment.
 load(file.js)
Specifies the path of a JavaScript file to execute.

load(file)
cat(file)

• function app(x, y) {
return (x + y);
}

• function app1(x, y, z) {
return (x + y + z);
}

• load("scripts/app.js")
• cat ("scripts/app.js")
 javascript function
• db.emp.find({$or:[ {job:'manager'}, {job:'salesman'} ]},
{}).forEach(function(doc) {
print (doc.ename.padEnd(12, "-") + doc.job);
});
• db.emp.find().forEach(function(doc) { • db.emp.find().forEach(function(doc) {
if (doc.ename == 'saleel') { x = doc.job.split(" ");
print (doc.ename, doc.job); print (x[0]);
} else { });
quit;
};
});

• db.emp.find().forEach((doc) => {
if (doc.ename.length >= 7) {
print(doc.ename + ": " +
doc.ename.length);
};
});
• db.emp.find().forEach(function(data) {
print("user: " +
data.ename.toUpperCase();)
});
 javascript function
• db.emp.find().forEach(function(doc) {
if(doc.job.split(' ')[1]=='Programmer' ||
doc.job=='programmer') {
print(doc.ename, doc.job);
}
});
• function findProductByID(_productID) {
return db.products.find({productID: _productID}, {_id:false,
productID:true, productname:true});
};

• function insertProduct(_productID, _productName, _color, _rate,

_qty) {
db.product.insert({
productID:_productID,
productName:_productName,
color:_color,
rate:_rate,
qty:_qty,
total:_qty * _rate
});
 javascript function
• function insertOnlyPune(id, _name, _sal, _comm, _city) {
if(_city == 'pune') {
db.abc.insertOne({
_id : id,
ename : _name,
sal: _sal,
comm : _comm,
grandSalary : _sal + _comm
})
};
};
 javascript function
• function deleteProduct(_productID) {
db.product.deleteOne({_id:_productID});
};
 javascript function
• function findProductByRangeID(_startID, _endID) {
return db.products.find({$and:[{productID:{$gte: _startID}},
{ productID:{$lte: _endID}}]}, {_id: false, productID:
true, productname: true });
};

• function productValidation(_productID) {
var x = db.products.find({productID:_productID}).count();
if (x != 0) {
return db.products.find({productID: _productID},
{_id:false,
productID:true, productname:true});
} else {
return ("Document not found!");
};
};
 db.collection.update()
Modifies an existing document or documents in a collection. The
method can modify specific fields of an existing document or
documents or replace an existing document entirely, depending on
the update parameter. By default, the update() method updates a
single document. Set the Multi Parameter to update all documents
that match the query criteria.
 db.collection.update()
By default, the update() method updates a single document. Set the
multi Parameter to update all documents that match the query criteria,
an upsert means an update than inserts a new document if no document
matches the filter.
db.collection.update({ query }, { update }, { options })
db.collection.update({ query }, { $set:{ update }}, { options })

Options : { $set: { field: value } }, { multi: true, upsert: true

}

• db.emp.update({ job: 'programmer' }, { job: 'sales' }, { upsert: true } );

• db.emp.update({ job: 'programmer' }, { $set: { job: 'sales' } }, { upsert :
true, multi: true });
• db.emp.update({ ename: 'ram' }, { $set : { size: 'small', color: ['red',
'blue'] } }, { multi: true } );
db.collection.updateOne()
updateOne() operations can add fields to existing documents using
the $set operator.
 db.collection.updateOne()
updateOne() updates a single document within the collection based on
the filter.
db.collection.updateOne({ filter }, { $set:{update} }, { options })

Options : { $set: { field: value } }, { upsert: true }

• db.emp.updateOne({ ename : 'ram' }, { $set : { job : 'programmer' } })

• db.emp.updateOne({ename : 'sham' }, { $set : { job : 'programmer' } },
{ upsert: true })
db.collection.updateMany()
updateMany() operations can add fields to existing documents
using the $set operator.
 db.collection.updateMany()
updateMany() updates multiple documents within the collection based on
the filter.
db.collection.updateMany({ filter }, { $set:{update} },
{ options })
Options : { $set: { field: value } }, { upsert: true }

• db.emp.updateMany({ sal: { $gt : 2000 } }, { $set: { color :

['red', 'yellow', 'green', 'blue'] } }, { upsert: true } );
 db.collection.deleteOne()
Removes a single document from a collection.
 db.collection.deleteOne()
deleteOne() removes a single document from a collection. Specify an
empty document { } to delete the first document returned in the collection.

db.collection.deleteOne({ filter })

• db.emp.deleteOne({})
• db.emp.deleteOne({ job: 'manager' })
db.collection.deleteMany()
Removes all documents that match the filter from a collection.
 db.collection.deleteMany()
deleteMany() removes all documents that match the filter from a
collection.

db.collection.deleteMany({ filter })

• db.emp.deleteMany({});
• db.emp.deleteMany({ job: 'manager' });
 “Accept your past without regret,
handle our present with confidence
and face your future without fear.“
A.P.J. Abdul Kalam