Introduction to MongoDB

ITERA UKRAINE 2017
Introduction to
MongoDB
ANTON FIL

https://university.mongodb.com/courses/M101J/about
• Introduction
• NoSQL
• CRUD
• Java driver
• Indexes
• Transactions
• Replication and sharding
AGENDA

What is MongoDB?
• MongoDB – is a free open-source cross-platform document-
oriented database program. Classified as NoSQL database, it uses
JSON-like documents.
• MongoDB is published under combination of GNU AGPL v3.0 and
Apache License v2.0 (for drivers).

Ranking of MongoDB
Complete ranking
Document stores
https://db-engines.com/en/ranking

Who uses MongoDB?
https://www.mongodb.com/who-uses-mongodb

Hosting of MongoDB
Free hostings are available:
1 DB, 512 MB, 3 Node Replica Set, Shared CPU/RAM
https://www.mongodb.com/cloud/atlas
https://mlab.com/plans/pricing/

What is NoSQL?
• NoSQL means “non sql”, “non relational”, sometimes “not only sql -
may support SQL-like languages queries”.
• Cluster-friendly. Triggered by the need of Google, Facebook to
process big data. NoSQL is much simpler for horizontal scaling to
clusters.
• Matching the data access patterns of your applications. The
data which is logically used together by application should be
aggregated into a single document.
• NoSQL simplifies the design of a databases. No schema. No
constraints.

Typical NoSQL document
{
'_id' : 1,
'name' : { 'first' : 'John', 'last' : 'Backus' },
'country': 'USA',
'contribs' : [ 'Fortran', 'ALGOL', 'Backus-Naur Form', 'FP' ],
'awards' : [
{
'award' : 'W.W. McDowell Award',
'year' : 1967,
'by' : 'IEEE Computer Society'
}, {
'award' : 'Draper Prize',
'year' : 1993,
'by' : 'National Academy of Engineering'
}
]
}

Shell and Server.
MongoDB distribution
contains 'client' and 'server'.
mongo.exe – Shell/Client
mongod.exe – Server

Database structure
MongoDB databases consist of collections. Collections consist
of documents.
• Collections vs tables
• Documents vs rows
• No Schema

JSON vs BSON
MongoDB stores documents as BSONs 16MB maximum.
http://bsonspec.org/spec.html
{"hello":"world"}
x16x00x00x00 // total document size
x02 // 0x02 = type String
hellox00 // field name with null terminator
x06x00x00x00 // size of value
worldx00 // field value with null terminator
x00 // 0x00 = type EOO ('end of object')

CRUD
insertOne
insertMany
find updateOne
updateMany
replaceOne
deleteOne
deleteMany

Insert
db.contributors.insertOne({
'_id' : NumberInt(1),
'country': 'USA',
'contribs' : [ 'Fortran', 'ALGOL', 'Backus-Naur Form', 'FP' ],
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
});

{
'_id' : 1,
'country': 'USA',
'contribs' : [ 'Fortran', 'ALGOL', 'FP' ],
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
db.contributors.find({
_id:1
});
Find by id

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
'name.first':'John',
country: 'USA'
});
Find by several fields

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
contribs: 'ALGOL'
});
Find in array

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
'awards.1.year': 1993
});
Find in array at concrete index

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
'awards.year': {
$gt: 1990,
$lt: 1985
}
});
$eq, $gt, $gte, $lt, $lte, $ne,
$in, $nin
https://docs.mongodb.com/manual/reference/operator/query-comparison/
Find using comparison operators

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
$or: [
{'awards.year': {$gt: 1990}},
{'awards.year': {$lt: 1966}}
]
});
$or, $and, $not, $nor
https://docs.mongodb.com/manual/reference/operator/query-logical/
Find using logical operators

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
awards: {$elemMatch: {
year: {$gt: 1990, $lt: 1985}
}}
});
contribs: {$all:['Fortran','ALGOL']}
});
db.contributors.find({awards: {$size:2}});
Find using array operators

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
Projection allows to select only
specified document fields.
db.contributors.find(
{'name.first': 'John'},
{
'name.last': 1,
country: 1,
_id: 0
}
);
Projection

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
db.contributors.updateOne(
{_id: 1},
{$set: {
'name.first': 'Mike',
country: 'Canada',
age: 60
}}
);
UpdateOne

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
db.contributors.updateMany(
{},
{$inc: {
'awards.0.year': 3,
'awards.4.year': 7
}}
);
$inc, $mul, $rename,
$unset, $min, $max,…
https://docs.mongodb.com/manual/reference/operator/update-field/
UpdateMany

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
{_id: 1},
{$push: {
awards: {
award: 'Best',
year: 1976,
by: 'MongoDB'
}
}}
);
Update arrays in documents

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
{_id: 1},
{$push: {awards: {$each: [
{'award': 'A', 'year': '', 'by': ''},
{'award': 'B', 'year': '', 'by': ''}
]}}}
);
$push, $addToSet, $pop, $pull,…
https://docs.mongodb.com/manual/reference/operator/update-array/
Update arrays in documents

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
{_id: 2},
{$push: {
awards: {
award: 'Best',
year: 1976,
by: 'MongoDB'
}
}},
{upsert: true}
);
Upsert

{
'_id' : 1,
'country': 'USA',
'awards' : [
{
'year' : 1967,
}, {
'year' : 1993,
}
]
}
db.contributors.replaceOne(
{_id: 1},
{$push: {
awards: {
award: 'Best',
year: 1976,
by: 'MongoDB'
}
}}
);
ReplaceOne

https://docs.mongodb.com/manual/aggregation/
SQL Terms, Functions, and Concepts MongoDB Aggregation Operators
WHERE $match
GROUP BY $group
HAVING $match
SELECT $project
ORDER BY $sort
LIMIT $limit
SUM() $sum
COUNT() $sum
join
$lookup
New in version 3.2.
Aggregation framework

<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver</artifactId>
<version>3.5.0</version>
</dependency>
final MongoClient mongoClient = new MongoClient(
new MongoClientURI("mongodb://localhost:27017"));
final MongoDatabase db = mongoClient.getDatabase("programming");
final MongoCollection<Document> coll = db.getCollection("contributors");
Document query = new Document().append("_id", 1);
Document contributor = coll.find(query).first();
mongoClient.close();
Connect to MongoDB using Java

coll.insertOne(contributor);
coll.insertMany(Arrays.asList(contributor1, contributor2));
coll.updateOne(...);
coll.updateMany(...);
coll.replaceOne(...);
coll.deleteOne(...);
coll.deleteMany(...);
CRUD in Java

import static com.mongodb.client.model.Filters.gt;
import static com.mongodb.client.model.Filters.lt;
import static com.mongodb.client.model.Filters.or;
import static com.mongodb.client.model.Projections.exclude;
import static com.mongodb.client.model.Projections.fields;
import static com.mongodb.client.model.Projections.include;
import static com.mongodb.client.model.Sorts.ascending;
import static com.mongodb.client.model.Sorts.descending;
import static com.mongodb.client.model.Sorts.orderBy;
...
List<Document> all = coll.find(or(gt("awards.year", 1990), lt("awards.year", 1966)))
.projection(fields(include("name.last", "country"), exclude("_id")))
.sort(orderBy(ascending("_id"), descending("name.first", "name.last")))
.skip(20)
.limit(10)
.into(new ArrayList<>());
Constructing queries in Java

import static com.mongodb.client.model.Updates.combine;
import static com.mongodb.client.model.Updates.inc;
import static com.mongodb.client.model.Updates.push;
import static com.mongodb.client.model.Updates.set;
...
coll.updateOne(
eq("_id", 1),
combine(set("name.first", "Anton"),
set("age", 30),
push("contribs", "Java"),
inc("awards.0.year", 1000))
);
Updating documents in Java

ODM vs ORM
Morphia
https://mongodb.github.io/morphia/

Spring Data MongoDB
https://projects.spring.io/spring-data-mongodb/

Performance
Storage engine is an interface between MongoDB server and Disk.
It determines data file format and format of indexes.
MMAPv1 – slow one, acquires collection-level lock during writes.
WiredTiger – fast one, uses document-level locking.

Indexes
Indexes increase search speed but descrease insert speed.
In MongoDB indexes are Btree separate data structures with
references to positions of documents.

Examples of indexes
for (var i = 0; i < 1000000; i++) {
db.people.insert({
name: 'Mike',
age: i
});
}
db.people.createIndex({name: 1, age: 1});
db.people.explain(true).find().sort({name: 1, age: 1}).limit(1); //Will use index
db.people.explain().find().sort({name: -1, age: -1}).limit(1); //Will use index
db.people.explain().find().sort({name: 1}).limit(1); //Will use index
db.people.explain().find().sort({name: -1}).limit(1); //Will use index
db.people.explain(true).find().sort({age: 1}).limit(1); //Will not use index
db.people.explain().find().sort({age: -1}).limit(1); //Will not use index
db.people.explain().find().sort({name: -1, age: 1}).limit(1); //Will not use index
db.people.explain().find().sort({name: 1, age: -1}).limit(1); //Will not use index

Transactions
• There are no Transactions
• There are atomic operations
• Update of each document is atomic. Document level locking is used.
Bulk update is not atomic.
• $isolated operator can be used to acquire lock on a the collection level
and make bulk update synchronized.
db.contributors.updateMany(
{'name.first': 'John', $isolated : 1},
{$set: {'name.first': 'Mike'}}
);

Write concern
Application
MongoDB
RAM
Pages
Journal
DISK
read
write
read
flush
flush
Acknowledgement
behavior
w=1
j=0
In RAM
w=1
j=1
On disk
w=0 No
acknowledgement
deprecated
On the level of client, collection and command we can set two parameters w/j.

Replication
mongod
(primary)
[oplog]
Application
mongod
(secondary)
[oplog]
mongod
(secondary)
[oplog]
read
Replication increases data availability and provides a level of fault tolerance
against the loss of a single database server. It also provide increased read
capacity.
Write concern
w=0,1,2,…,n, majority
j=0,1

Creating replica sets on Windows
start mongod --replSet rs1 --logpath 1.log --dbpath datars1 --port 27017 --smallfiles --oplogSize 64
mongo --port 27017
config = {_id: "rs1", members: [
{_id: 0, host: "localhost:27017"},
{_id: 1, host: "localhost:27018"},
{_id: 2, host: "localhost:27019"}
]};
rs.initiate(config);
rs.status();

Connect to replica sets from Java
mongoClient = new MongoClient(
Arrays.asList(
new ServerAddress("localhost", 27017),
new ServerAddress("localhost", 27018),
new ServerAddress("localhost", 27019)),
MongoClientOptions.builder()
.requiredReplicaSetName("rs1")
.readPreference(ReadPreference.secondaryPreferred())
.writeConcern(WriteConcern.W1.withJournal(true))
.build());

Sharding
Sharding – is a method for
splitting single collection
across multiple servers.
It provides support of very
large data sets and high
throughput of operations.
To split collection across
multiple servers a collection
shard key should be
provided.

• MongoDB provides extensive and
intuitively understandable query
language which is not inferior to the
SQL
• MongoDB provides extensive
capabilities for investigation of queries
execution plans and performance
issues including sharded environments
• MongoDB provides extensive
capabilities for Replication and
Sharding
CONCLUSION

Introduction to MongoDB

More Related Content

What's hot (18)

Similar to Introduction to MongoDB (20)

Recently uploaded (20)

Introduction to MongoDB

Editor's Notes