Outline

Indexing

Aggregation
Indexing
•Indexes support the
efficient execution of
queries in MongoDB.
 Indexing Types
• A single field index only includes data from a single field of the
Single Field Indexes documents in a collection.

• A compound index includes more than one field of the documents in

Compound Indexes a collection.

• A multikey index is an index on an array field, adding an index key for

Multikey Indexes each value in the array.

Geospatial Indexes • Geospatial indexes support location-based searches.

and Queries

Text Indexes • Text indexes support search of string content in documents.

• Hashed indexes maintain entries with hashes of the values of the

Hashed Index indexed field and are used with sharded clusters to support hashed
shard keys.
 Index Properties
TTL Indexes The TTL index is
used for TTL collections,
which expire data after a
period of time.

Unique Indexes A unique

Index Properties The
index causes MongoDB to
properties you can
reject all documents that
specify when
contain a duplicate value for
building indexes.
the indexed field.

Sparse Indexes A sparse

index does not index
documents that do not have
the indexed field.
 Index Creation

Using CreateIndex
• db.CollectionName.createIndex( { KeyName: 1 or -1})

Using ensureIndex
• db.CollectionName.ensureIndex({KeyName: 1 or -1})

1 for Ascending Sorting

-1 for Descending Sorting
 Index Creation

Using CreateIndex
• Single: db.stud.createIndex( { zipcode: 1})
• Compound: db.stud.createIndex( { dob: 1, zipcode: -1 } )
• Unique: db.stud.createIndex( { rollno: 1 }, { unique: true } )
• Sparse: db.stud.createIndex( { age: 1 }, { sparse: true } )

Using ensureIndex
• Single: db.stud.ensureIndex({“name":1})
• Compound: db.stud.ensureIndex ({“address":1,“name":-1})
 Index Display
db.collection.getIndexes()
• Returns an array that holds a list of
documents that identify and describe the
existing indexes on the collection.

db.collection.getIndexStats()
• Displays a human-readable summary of aggregated
statistics about an index’s B-tree data structure.
• db.<collection>.getIndexStats( { index : "<index name>" } )
 Index Drop

Syntax
• db.collection.dropIndex()
• db.collection.dropIndex(index)
Example
• db.stud.dropIndex()
• db.stud.dropIndex( { “name" : 1 } )
 Indexing and Querying
• create an ascending index on the field name for a collection
records:
db.records.createIndex( { name: 1 } )
• This index can support an ascending sort on name :
db.records.find().sort( { name: 1 } )
• The index can also support descending sort
db.records.find().sort( { a: -1 } )
 Indexing and Querying
db.stud.findOne( {rno:2} ), using index {rno:1}

db.stud.find ( {rno:5} ), using index {rno:1}

db.stud.find( {rno:{$in:[2,3]}} ), using index {rno:1}

db.stud.find( {age:{$gt:15}} ), using index {age:1}

db.stud.find( {age :{$gt:2,$lt:5}} ), using index {age :1}

db.stud.count( {age:19} ) using index {age:1}

db.stud.distinct( {branch: “Computer”} ) using index

{branch:1}
 Indexing and Querying
db.stud.find({}, {name:1,age:1}),
using index {name:1,age:1}

db.c.find().sort( {name:1,age:1} ),
using index {name:1,age:1}

db.stud.update( {age:20}, {age:19} )

using index {age:1}

db.stud.remove( {name: “Jiya”} )

using index {name:1}
Indexing with Unique
db.collectionname.ensureIndex
( {x:1}, {unique:true} )

• Don’t allow {_id:10,x:2} and {_id:11,x:2}

• Don’t allow {_id:12} and {_id:13} (both match {x:null}

What if duplicates exist before index is

created?
• Normally index creation fails and the index is removed
• db.ensureIndex( {x:1}, {unique:true,dropDups:true} )
Outline

Indexing

Aggregation
Aggregation
Aggregations 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

For aggregation in mongodb use aggregate() method.

Syntax:

• >db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)
Aggregation
• MongoDB’s aggregation framework is modeled on the concept
of data processing pipelines.
• Documents enter a multi-stage pipeline that transforms the
documents into an aggregated result.
• Other pipeline operations provide tools for grouping and
sorting documents by specific field or fields.
• In addition, pipeline stages can use operators for tasks such as
calculating the average or concatenating a string.
aggregate() method
Expression Description
Sums up the defined value from all documents in the
$sum
collection.
Calculates the average of all given values from all
$avg
documents in the collection.
Gets the minimum of the corresponding values from all
$min
documents in the collection.
Gets the maximum of the corresponding values from all
$max
documents in the collection.
Gets the first document from the source documents
$first
according to the grouping.
Gets the last document from the source documents
$last
according to the grouping.
Pipeline Concept

There is a set of possible

stages and each of those is
taken as a set of documents
as an input and produces a
resulting set of documents
Possible stages in aggregation
• $project − Used to select some specific fields from a collection.
• $match − This is a filtering operation and thus this can reduce the
amount of documents that are given as input to the next stage.
• $group − This does the actual aggregation as discussed above.
• $sort − Sorts the documents.
• $skip − With this, it is possible to skip forward in the list of
documents for a given amount of documents.
• $limit − This limits the amount of documents to look at, by the given
number starting from the current positions.
• $unwind − This is used to unwind document that are using arrays.
When using an array, the data is kind of pre-joined and this
operation will be undone with this to have individual documents
again. Thus with this stage we will increase the amount of
documents for the next stage.
Collection creation to run practical
• db.student.insert({Rollno:1,name:'Navin ',subject:'DMSA',marks:78});
db.student.insert({Rollno:2,name:'anusha',subject:'OSD',marks:75});
db.student.insert({Rollno:3,name:'ravi',subject:'TOC',marks:69});
db.student.insert({Rollno:4,name:'veena',subject:'TOC',marks:70});
db.student.insert({Rollno:5,name: ‘Pravini',subject: ‘OSD',marks:80});
db.student.insert({Rollno:6,name: ‘Reena',subject: ‘DMSA',marks:50});
db.student.insert({Rollno:7,name: ‘Geeta',subject: ‘CN',marks:90});
db.student.insert({Rollno:8,name: ‘Akash',subject: ‘CN',marks:85});
MIN()

db.student.aggregate
([{$group : {_id : "$subject",
marks : {$min : "$marks"}}}]);

SQL Equivalent Query

Select subject, min(marks) from student
group by subject
MAX()

db.student.aggregate
([{$group : {_id : "$subject",
marks : {$max : "$marks"}}}]);

SQL Equivalent Query

Select subject, max(marks) from student
group by subject
AVG()

db.student.aggregate
([{$group : {_id : "$subject",
marks : {$avg : "$marks"}}}]);

SQL Equivalent Query

Select subject, avg(marks) from student
group by subject
FIRST()

db.student.aggregate
([{$group : {_id : "$subject",
marks : {$first : "$marks"}}}]);
LAST()

db.student.aggregate
([{$group : {_id : "$subject",
marks : {$last : "$marks"}}}]);
SUM()-Example 1
db.student.aggregate
([{$group : {_id : "$subject",
marks : {$sum : "$marks"}}}]);

SQL Equivalent Query

Select subject, sum(marks) from student
group by subject
SUM(): Example 2
db.student.aggregate
([{$group : {_id : "$subject",
Count: {$sum : 1}}}]);

SQL Equivalent Query

Select subject, count(*) from student
group by subject
$match

db.student.aggregate
([{ $match: {subject:"OSD"}}])

db.student.aggregate
([{ $match: {subject:"OSD"}},
{$group:{_id:null,count:{$sum:1}}}]);
SUM()- Example 3

db.student.aggregate
([{ $match: {subject:"OSD"}},
{$group:{_id:null,count:{$sum:1}}}]);

SQL Equivalent Query

Select subject, count(*) from student
group by subject
having subject=“OSD”
Limit() & Skip()

db.student.aggregate
([{ $match: {subject:"OSD"}},
{$limit:1}]);

db.student.aggregate
([{ $match: {subject:"OSD"}},
{$skip:1}]);
Sort()

db.student.aggregate
([{ $match: {subject:"OSD"}},
{$sort:{marks:-1}}]);

db.student.aggregate
([{ $match: {subject:"OSD"}},
{$sort:{marks:1}}]);
Unwind()

If following document is their in collection(Array)

• db.student.insert({rollno:9,name:"Anavi",marks:[80,30,50]});

Using Unwind the above document will be

unwinded into 3 different document

• db.student.aggregate([{$unwind:"$marks"}])
Refernces
• https://www.tutorialspoint.com/mongodb/mongodb_aggrega
tion.htm
• http://pradipshewale.blogspot.in/2015/09/aggregation-and-
indexing-with-suitable.html
• https://www.infoq.com/articles/implementing-aggregation-
functions-in-mongodb
• http://docs.mongodb.org/manual/reference/operator/aggreg
ation/