Mongodb Introduction

An introduction to MongoDB
Raghvendra Parashar
raghvendra@gemsessence.com

MongoDB is a cross-platform, document oriented database that provides, high performance,
high availability, and easy scalability. MongoDB works on concept of collection and
document.
It is leading NoSQL database. MongoDB is written in c++.
Latest Production Release (3.0.0) — 3/3/2015
http://www.mongodb.org/downloads

NoSQL products (and among them MongoDB) should be used to meet challenges. If you have
one of the following challenges, you should consider MongoDB:
➔ You Expect a High Write Load
➔ You need High Availability in an Unreliable Environment
➔ You need to Grow Big (and Shard Your Data)
➔ Your Data is Location Based
➔ Your Data Set is Going to be Big (starting from 1GB) and Schema is Not Stable
http://java.dzone.com/articles/when-use-mongodb-rather-mysql

● Database
Database is a physical container for collections. Each database gets its own set of files on the
file system. A single MongoDB server typically has multiple databases.
● Collection
Collection is a group of MongoDB documents. It is the equivalent of an RDBMS table. A
collection exists within a single database. Collections do not enforce a schema. Documents
within a collection can have different fields. Typically, all documents in a collection are of
similar or related purpose.
● Document
A document is a set of key-value pairs. Documents have dynamic schema. Dynamic schema
means that documents in the same collection do not need to have the same set of fields or
structure, and common fields in a collection's documents may hold different types of data.

Features
•Document-Oriented storage
•Full Index Support
•Replication & High Availability
•Auto-Sharding
•Querying
•Fast In-Place Updates
•GridFS

● Document Database
○ Documents (objects) map nicely to programming language data types.
○ Embedded documents and arrays reduce need for joins.
○ Dynamic schema makes polymorphism easier.
● High Performance
○ Embedding makes reads and writes fast.
○ Indexes can include keys from embedded documents and arrays.
○ Optional streaming writes (no acknowledgments).
● High Availability
○ Replicated servers with automatic master failover.
● Easy Scalability
○ Automatic sharding distributes collection data across machines.
○ Eventually-consistent reads can be distributed over replicated servers.

RDBMS MongoDB
Database Database
Table Collection
Tuple/Row Document
column Field
Table Join Embedded Documents
Primary Key Primary Key (Default
key _id provided by
mongodb itself)
Database Server and Client
Mysqld/Oracle mongod
mysql/sqlplus mongo
Below given table shows the relationship of RDBMS terminology with MongoDB

Below given example shows
the document structure of a blog site which is simply a comma separated key value pair.
{
_id: ObjectId(7df78ad8902c)
title: 'MongoDB Overview',
description: 'MongoDB is no sql database',
by: 'tutorials point',
url: 'http://www.tutorialspoint.com',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 100,
comments: [
{
user:'user1',
message: 'My first comment',
dateCreated: new Date(2011,1,20,2,15),
like: 0
},
{
user:'user2',
message: 'My second comments',
dateCreated: new Date(2011,1,25,7,45),
like: 5
}
]
}
_id is a 12 bytes hexadecimal number which assures the uniqueness of every document. You can
provide _id while inserting the document. If you didn't provide then MongoDB provide a unique id
for every document. These 12 bytes first 4 bytes for the current timestamp, next 3 bytes for
machine id, next 2 bytes for process id of mongodb server and remaining 3 bytes are simple
incremental value.
Sample document

1. Document-Oriented storage
Example
Suppose a client needs a database design for his blog website and see
the differences between RDBMS and MongoDB schema design. Website
has the following requirements.
● Every post has the unique title, description and url.
● Every post can have one or more tags.
● Every post has the name of its publisher and total number of likes.
● Every Post have comments given by users along with their name,
message, data-time and likes.
● On each post there can be zero or more comments.
In RDBMS schema design for above requirements will have minimum
three tables.

So while showing the data, in RDBMS you need to join three tables and in mongodb
data will be shown from one collection only.
While in MongoDB schema design will have one collection post and has the following structure:
{
_id: POST_ID
title: TITLE_OF_POST,
description: POST_DESCRIPTION,
by: POST_BY,
url: URL_OF_POST,
tags: [
TAG1,
TAG2,
TAG3
],
likes: TOTAL_LIKES,
comments: [
{
user: 'COMMENT_BY',
message: TEXT,
dateCreated: DATE_TIME,
like: LIKES
},
{
user: 'COMMENT_BY',
message: TEXT,
dateCreated: DATE_TIME,
like: LIKES
}
]
}

The createCollection() Method
MongoDB db.createCollection(name, options) is used to create collection.
SYNTAX:
Basic syntax of createCollection() command is as follows
db.createCollection(name, options)
In the command, name is name of collection to be created. Options is a document and used
to specify configuration of collection
Parameter Type Description
Name String Name of the collection to be created
Options Document (Optional) Specify options about
memory size and indexing
Options parameter is optional, so you need to specify only name of the collection.

Following is the list of options you can use:
Field Type Description
capped Boolean (Optional) If true, enables a capped collection. Capped
collection is a collection fixed size collecction that
automatically overwrites its oldest entries when it reaches
its maximum size. If you specify true, you need to specify
size parameter also.
autoIndexI
D
Boolean (Optional) If true, automatically create index on _id field.s
Default value is false.
size number (Optional) Specifies a maximum size in bytes for a capped
collection. IfIf capped is true, then you need to specify
this field also.
max number (Optional) Specifies the maximum number of documents
allowed in the capped collection.
While inserting the document, MongoDB first checks size field of capped collection,
then it checks max field.

_id is 12 bytes hexadecimal number unique for every document in a collection. 12 bytes are
divided as follows:
_id: ObjectId(4 bytes timestamp, 3 bytes machine id, 2 bytes process id, 3 bytes incrementer
MongoDB supports many data-types whose list is given below:
● String : This is most commonly used datatype to store the data. String in
mongodb must be UTF-8 valid.
● Integer : This type is used to store a numerical value. Integer can be 32 bit or 64
bit depending upon your server.
● Boolean : This type is used to store a boolean (true/ false) value.
● Double : This type is used to store floating point values.
● Arrays : This type is used to store arrays or list or multiple values into one key.
● Timestamp : This can be handy for recording when a document has been
modified or added.
● Object : This datatype is used for embedded documents.
● Object ID : This datatype is used to store the document’s ID.

2. Full Index Support
Indexes support the efficient resolution of queries. Without indexes,
MongoDB must scan every document of a collection to select those
documents that match the query statement. This scan is highly inefficient
and require the mongod to process a large volume of data.
Indexes are special data structures, that store a small portion of the data
set in an easy to traverse form. The index stores the value of a specific
field or set of fields, ordered by the value of the field as specified in index.
The ensureIndex() Method
To create an index you need to use ensureIndex() method of mongodb.

SYNTAX:
Basic syntax of ensureIndex() method is as follows()
>db.COLLECTION_NAME.ensureIndex({KEY:1})
Here key is the name of field on which you want to create index and 1 is
for ascending order. To create index in descending order you need to use
-1.
EXAMPLE
>db.mycol.ensureIndex({"title":1})
>
In ensureIndex() method you can pass multiple fields, to create index on
multiple fields.
>db.mycol.ensureIndex({"title":1,"description":-1})
>

Parameter Type Description
background Boolean Builds the index in the background so that building an index does not block other database activities. Specify true
to build in the background. The default value is false.
unique Boolean Creates a unique index so that the collection will not accept insertion of documents where the index key or keys
match an existing value in the index. Specify true to create a unique index. The default value is false.
name string The name of the index. If unspecified, MongoDB generates an index name by concatenating the names of the
indexed fields and the sort order.
dropDups Boolean Creates a unique index on a field that may have duplicates. MongoDB indexes only the first occurrence of a key
and removes all documents from the collection that contain subsequent occurrences of that key. Specify true to
create unique index. The default value isfalse.
sparse Boolean If true, the index only references documents with the specified field. These indexes use less space but behave
differently in some situations (particularly sorts). The default value is false.
expireAfterSeconds integer Specifies a value, in seconds, as a TTL to control how long MongoDB retains documents in this collection.
v index
version
The index version number. The default index version depends on the version of mongod running when creating
the index.
weights document The weight is a number ranging from 1 to 99,999 and denotes the significance of the field relative to the other
indexed fields in terms of the score.
default_language string For a text index, the language that determines the list of stop words and the rules for the stemmer and tokenizer.
The default value is english.
language_override string For a text index, specify the name of the field in the document that contains, the language to override the default
language. The default value is language.

RDBMS Where Clause Equivalents in MongoDB
Operation Syntax Example RDBMS Equivalent
Equality {<key>:<value>} db.mycol.find({"by":"tutorials
point"}).pretty()
where by =
'tutorials point'
Less Than {<key>:{$lt:
<value>}}
db.mycol.find({"likes":{$lt:50}}).
pretty()
where likes < 50
Less Than
Equals
{<key>:{$lte:
<value>}}
db.mycol.find({"likes":{$lte:50}}).
pretty()
where likes <= 50
Greater Than {<key>:{$gt:
<value>}}
db.mycol.find({"likes":{$gt:50}}).
pretty()
where likes > 50
Greater Than
Equals
{<key>:{$gte:
<value>}}
db.mycol.find({"likes":{$gte:50}}).
pretty()
where likes >= 50
Not Equals {<key>:{$ne:
<value>}}
db.mycol.find({"likes":{$ne:50}}).
pretty()
where likes != 50
To query the document on the basis of some condition, you can use following operations

3. Replication & High Availability
Replication is the process of synchronizing data across multiple
servers. Replication provides redundancy and increases data
availability with multiple copies of data on different database
servers, replication protects a database from the loss of a single
server. Replication also allows you to recover from hardware failure
and service interruptions. With additional copies of the data, you
can dedicate one to disaster recovery, reporting, or backup.
Why Replication?
● To keep your data safe
● High (24*7) availability of data
● Disaster Recovery
● No downtime for maintenance (like backups, index rebuilds)
● Read scaling (extra copies to read from)

How replication works in MongoDB
MongoDB achieves replication by the use of replica set. A replica set is a group of
mongod instances that host the same data set. In a replica one node is primary node
that receives all write operations. All other instances, secondaries, apply operations
from the primary so that they have the same data set. Replica set can have only one
primary node.
1. Replica set is a group of two or more nodes (generally minimum 3 nodes are
required).
2. In a replica set one node is primary node and remaining nodes are secondary.
3. All data replicates from primary to secondary node.
4. At the time of automatic failover or maintenance, election establishes for primary
and a new primary node is elected.
5. After the recovery of failed node, it again join the replica set and works as a
secondary node.
A typical diagram of mongodb replication is shown in which client application always
interact with primary node and primary node then replicate the data to the secondary
nodes.

Replica set features
● A cluster of N nodes
● Anyone node can be primary
● All write operations goes to primary
● Automatic failover
● Automatic Recovery
● Consensus election of primary

Create MongoDB Replica set
Create 3 local MongoDB instances
● Make data directory
● mkdir -p /data/r0
mkdir -p /data/r1
mkdir -p /data/r2
● Start 3 local instances
● mongod --replSet cluster1 --port 27017 --dbpath /data/r0
mongod --replSet cluster1 --port 27018 --dbpath /data/r1
mongod --replSet cluster1 --port 27019 --dbpath /data/r2

● Add instance(s) to a cluster
● mongo myhost:27017
config = {_id: 'cluster1', members: [
{_id: 0, host: 'myhost1:27017'},
{_id: 1, host: 'myhost2:27018'},
{_id: 2, host: 'myhost3:27019'}]
}
rs.initiate(config);
cluster1:PRIMARY> rs.status()
ref : http://www.jonathanhui.com/mongodb-replication-replica-set

Vertical scaling Horizontal scaling

Sharding Introduction
Sharding is a method for storing data across multiple machines. MongoDB uses sharding to
support deployments with very large data sets and high throughput operations.
http://www.jonathanhui.com/mongodb-sharding
Purpose of Sharding
Database systems with large data sets and high throughput applications can
challenge the capacity of a single server. High query rates can exhaust the CPU
capacity of the server. Larger data sets exceed the storage capacity of a single
machine. Finally, working set sizes larger than the system’s RAM stress the I/O
capacity of disk drives.
To address these issues of scales, database systems have two basic approaches:
vertical scaling and sharding.
Vertical scaling adds more CPU and storage resources to increase capacity.
Scaling by adding capacity has limitations: high performance systems with large
numbers of CPUs and large amount of RAM are disproportionately more expensive
than smaller systems. Additionally, cloud-based providers may only allow users to
provision smaller instances. As a result there is a practical maximum capability for
vertical scaling.
Sharding, or horizontal scaling, by contrast, divides the data set and distributes the
data over multiple servers, or shards. Each shard is an independent database, and
collectively, the shards make up a single logical database.

Sharded cluster has the following components: shards, query routers and config servers.
Shards store the data. To provide high availability and data consistency, in a production
sharded cluster, each shard is a replica set.
Query Routers, or mongos instances, interface with client applications and direct operations
to the appropriate shard or shards. The query router processes and targets operations to
shards and then returns results to the clients. A sharded cluster can contain more than one
query router to divide the client request load. A client sends requests to one query router. Most
sharded clusters have many query routers.
Config servers store the cluster’s metadata. This data contains a mapping of the cluster’s
data set to the shards. The query router uses this metadata to target operations to specific
shards. Production sharded clusters have exactly 3 config servers.

GridFS
GridFS is a specification for storing and retrieving files that exceed the BSON-document size
limit of 16MB.
Instead of storing a file in a single document, GridFS divides a file into parts, or chunks, [1] and
stores each of those chunks as a separate document. By default GridFS limits chunk size to
255k. GridFS uses two collections to store files. One collection stores the file chunks, and the
other stores file metadata.

There are several courses runing by mongodb university, you can learn from here also
https://university.mongodb.com/courses/catalog
https://university.mongodb.com/courses/M102/about
You can try mongo queries here
http://try.mongodb.org/
Download:
http://www.mongodb.org/downloads
Refe:
http://www.mongodb.org/
http://www.jonathanhui.com/mongodb
http://www.tutorialspoint.com/mongodb/

Mongodb Introduction

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Mongodb Introduction (20)

Recently uploaded (20)

Mongodb Introduction