The document discusses MongoDB and how it allows storing data in flexible, document-based collections rather than rigid tables. Some key points: - MongoDB uses a flexible document model that allows embedding related data rather than requiring separate tables joined by foreign keys. - It supports dynamic schemas that allow fields within documents to vary unlike traditional SQL databases that require all rows to have the same structure. - Aggregation capabilities allow complex analytics to be performed directly on the data without requiring data warehousing or manual export/import like with SQL databases. Pipelines of aggregation operations can be chained together.

2. Developer Advocate EMEA @MongoDB Paris
@MBeugnet
MaBeuLux88
maxime@mongodb.com
Meetups
Workshops
Conferences
Hackathons
Webinars

3. 3
MongoDB’s
Intelligent Operational Data Platform
is the best way of making your data simple
to Organize, Use, & Enrich
in Real Time, Anywhere

4. You probably have thousands of tables

5. 5
Go from this….
Customer Opportunity Contact
Opportunity
Team
Phone Phone
Objects
Tables
Lead
NameNameOpen Activities
ARR Address Contact Roles
SummaryCustomer Detail Activity History
Object Relational Mapping Layer

6. 6
To this: store objects directly…
Customer
Customer
Opportunity
Opportunity
Contact
Contact
Lead
Lead
Objects
Database

7. 7
Document Model
{
first_name: ‘Paul’,
surname: ‘Miller’,
city: ‘London’,
location: {
type : ‘Point’,
coordinates : [45.123,47.232]
},
cars: [
{ model: ‘Bentley’,
year: 1973,
value: 100000, … },
{ model: ‘Rolls Royce’,
year: 1965,
value: 330000, … }
]
}
MongoDB
RDBMS

8. 8
Developer Agility - Documents
{
first_name: ‘Paul’,
surname: ‘Miller’,
ID: 125678,
city: ‘London’,
location: {
type : ‘Point’,
coordinates : [45.123,47.232]
},
Profession: [‘banking’, ‘finance’, ‘trader’],
cars: [
{ model: ‘Bentley’,
year: 1973,
value: 100000, … },
{ model: ‘Rolls Royce’,
year: 1965,
value: 330000, … }
]
}
Fields can contain an array
of sub-documents
Typed field values
Fields can contain
arrays
String
Number
Geo-Location
Fields

9. 9
Developer Agility – Flexible Schema
{
product_name: ‘Acme Paint’,
sku: "123-567-845",
color: [‘Red’, ‘Green’],
size_oz: [8, 32],
finish: [‘satin’, ‘eggshell’]
}
{
product_name: ‘T-shirt’,
sku : "123-589-234",
size: [‘S’, ‘M’, ‘L’, ‘XL’],
color: [‘Heather Gray’ … ],
material: ‘100% cotton’,
wash: ‘cold’,
dry: ‘tumble dry low’
}
{
product_name: ‘Mountain Bike’,
sku : "143-534-678",
brake_style: ‘mechanical disc’,
color: ‘grey’,
frame_material: ‘aluminum’,
no_speeds: 21,
package_height: ‘7.5x32.9x55’,
weight_lbs: 44.05,
suspension_type: ‘dual’,
wheel_size_in: 26
}

10. 10
Developer Agility – Use Your Favourites
Morphia
MEAN Stack

11. 11
Fully Indexable
Fully featured secondary indexes
• Primary Index
Every Collection has a primary key index
• Compound Index
Index against multiple keys in the document
• MultiKey Index
Index into arrays
• Text Indexes
Support for text searches
• GeoSpatial Indexes
2d & 2dsphere indexes for spatial geometries
• Hashed Indexes
Hashed based values for sharding
Index Types
• TTL Indexes
Single Field indexes, when expired delete the document
• Unique Indexes
Ensures value is not duplicated
• Partial Indexes
Expression based indexes, allowing indexes on subsets of data
• Case Insensitive Indexes
supports text search using case insensitive search
• Sparse Indexes
Only index documents which have the given field
Index Features

12. 12
Aggregations
Advanced data processing
pipeline for transformations
and analytics
• Multiple stages
• Similar to a unix pipe
Build complex pipeline by
chaining commands together
• Rich Expressions
Collection
db.orders.aggregate( [
$match stage { $match: { status: "A" } },
$group stage { $group: { _id: "$cust_id",total: { $sum: "$amount" } } }
] )
{
cust_id: "A123",
amount: 500,
status: "A",
}
{
cust_id: "A123",
amount: 250,
status: "A",
}
{
cust_id: "B212",
amount: 200,
status: "A",
}
{
cust_id: "A123",
amount: 300,
status: "D",
}
Orders
{
cust_id: "A123",
amount: 500,
status: "A",
}
{
cust_id: "A123",
amount: 250,
status: "A",
}
{
cust_id: "B212",
amount: 200,
status: "A",
}
{
id: "A123",
total: 750
}
{
id: "B212",
total: 200
}
$match $group

13. 13
Aggregation Features
A feature rich analytical framework
• $match
• $group
• $facet
• $geoNear
• $graphLookup
Pipeline Stages
• Mathematical
$add, $abs,
$substract,
$multiply, $divide,
$log, $log10,
$stdDevPop,
$stdDevSam, $avg,
$sqrt, $pow, $sum,
$zip, $convert, etc.
• Array
$push, $reduce,
$reverseArray,
$addToSet,
$arrayElemAt,
$slice, etc.
Operators
• $lookup
• $project
• $sort
• $unwind
• $out
• Conditionals
$and, $or, $eq, $lt,
$lte, $gt, $gte,
$cmp, $cond,
$switch, $in, etc
• Date
$dateFromParts,
$dateToParts,
$dateFromString,
$dateToString,
$dayOfMonth,
$isoWeek, $minute,
$month, $year, etc.
• String
$toUpper, $toLower,
$substr,
$strcasecmp,
$concat, $split, etc.
• Laterals
$exp, $let, $literal,
$map, $type, etc

14. 14
Compared to SQL JOINs and aggregation
SELECT
city,
SUM(annual_spend) Total_Spend,
AVG(annual_spend) Average_Spend,
MAX(annual_spend) Max_Spend,
COUNT(annual_spend) customers
FROM (
SELECT t1.city, customer.annual_spend
FROM customer
LEFT JOIN (
SELECT address.address_id, city.city,
address.customer_id, address.location
FROM address LEFT JOIN city
ON address.city_id = city.city_id
) AS t1
ON
(customer.customer_id = t1.customer_id AND
t1.location = "home")
) AS t2
GROUP BY city;
SQL queries have a
nested structure
Understanding the outer
layers requires
understanding the inner
ones
So SQL has to be read
“inside-out”

15. 15
db.customers.aggregate([
{
$unwind: "$address",
},
{
$match: {"address.location": "home"}
},
{
$group: {
_id: "$address.city",
totalSpend: {$sum: "$annualSpend"},
averageSpend: {$avg: "$annualSpend"},
maximumSpend: {$max: "$annualSpend"},
customers: {$sum: 1}
}
}
])
Versatile: Complex queries fast to create, optimize, & maintain
MongoDB’s aggregation framework has the flexibility you need to get
value from your data, but without the complexity and fragility of SQL
These “phases” are distinct and
easy to understand
They can be thought about in
order… no nesting.

16. 16
Developer Agility – Compass – MongoDB GUI
Debug & Optimize
Visualize & Explore
Insert, Modify, & Delete

17. 17
High Availability and Data Durability – Replica Sets
SecondarySecondary
Primary

18. 18
Replica Set Creation
SecondarySecondary
Primary
Heartbeat

19. 19
Replica Set Node Failure
SecondarySecondary
Primary
No Heartbeat

20. 20
Replica Set Recovery
SecondarySecondary
Heartbeat
And Election

21. 21
New Replica Set – 2 Nodes
SecondaryPrimary
Heartbeat
And New Primary

22. 22
Replica Set Repair
SecondaryPrimary
Secondary
Rejoin and resync

23. 23
Replica Set Stable
SecondaryPrimary
Secondary
Heartbeat

24. 24
Strong Consistency
SecondarySecondary
Primary
Client Application
Client Driver
Write
Read

25. 25
Eventual Consistency
SecondarySecondary
Primary
Client Application
Client Driver
Write
Read
Read

26. Developing with MongoDB
Application
Driver
mongod
/data

27. 27
Replica Set
Read Preference
Write Concern
Read Concern

28. #MDBlocal#MDBlocal
MongoDB 3.6 adds compression
of wire protocol traffic between
client and database
• Up to 80% bandwidth savings
MongoDB End to End
Compression
• Wire protocol
• Intra-cluster
• Indexes in memory
• Storage
Application
MongoDB Primary
Replica
Wire Protocol
Compression
MongoDB Secondary Replica
Single ViewMongoDB Secondary Replica
Single ViewMongoDB Secondary Replica
Single ViewMongoDB Secondary Replica
Single ViewMongoDB Secondary Replica
MongoDB Secondary Replica
Intra-Cluster
Compression
Compression
of
Data on Disk
Compression of
Indexes in
Memory
End to End Compression

29. #MDBlocal#MDBlocal
DNS seed list
mongodb://example1.com:27017,example2.com:27017,example3.com:27017?
replicaSet=myName
mongodb+srv://my-dns-server.mongodb.com
mongodb://example1.com:27017

30. #MDBlocal#MDBlocal
JSON Schema
Enforces strict schema structure over a complete collection
for data governance & quality
• Builds on document validation introduced by restricting new content that
can be added to a document
• Enforces presence, type, and values for document content, including
nested array
• Simplifies application logic
Tunable: enforce document structure, log warnings, or allow
complete schema flexibility
Queryable: identify all existing documents that do not comply

31. #MDBlocal#MDBlocal
JSON Schema
db.createCollection( "orders",
{validator: {$jsonSchema:
{properties:
{line_items:
{type: "array",
items:
{properties:
{title: {type: "string"},
price: {type: "number", minimum: 0.0} },
required: ["_id", "title", "price"],
additionalProperties: false}}},
required: ["line_items"]}}}
)

32. 32
Versatile: MongoDB Change Streams
Enabling developers to build
reactive, real-time servicesChangeStreamsAPI
Business
Apps
User Data
Sensors
Clickstream
Real-Time
Event Notifications
Message Queue

33. Change Streams
db.coll.watch()
db.coll.watch([{$match: {operationType: “insert”}}])
db.coll.watch([], {fullDocument:“updateLookup”})
db.coll.watch([], {resumeAfter:<cachedResumeToken>})
•
•
•
•
•

34. Change Streams => cursors
cursor = db.users.watch([ ], {"fullDocument":"updateLookup"});
while ( !cursor.isExhausted() ) {
if ( cursor.hasNext() ) {
print(tojson(cursor.next()));
}
}

35. Characteristics of Change Streams
•Resumable
•Targeted Changes
•Total ordering
•Durability
•Security
•Ease of use
•Idempotence

36. Characteristics of Retryable Writes
•Automatic Drivers logic
• Network errors
• Elections
• NOT for logic errors
•Safe
• For both non-idempotent and idempotent writes
• NOT for multi: true

37. Retryable Writes => Super easy!
uri = "mongodb://example.com:27017/?retryWrites=true"
client = MongoClient(uri)
database = client.database
collection = database.collection

38. 38
Easy: MongoDB Multi-Document ACID Transactions
Just like relational transactions
• Multi-statement, familiar relational syntax
• Easy to add to any application
• Multiple documents in 1 or many collections and
databases
ACID guarantees
• Snapshot isolation, all or nothing execution
• No performance impact for non-transactional operations
Planning
• MongoDB 4.0: replica set
• MongoDB 4.2: extended to sharded clusters

39. 39
Sophisticated Analytics & Visualizations Of Data In Place
• Rich MongoDB query
language & idiomatic
drivers
• Connector for BI
• Connector for Spark
• Charts (beta)

40. MongoDB Charts: Create, Visualize, Share
Work with complex data Connect to data sources securely.
Filter. Sample. Visualize.
Share dashboards and
collaborate

41. 41
Replica Set Bottlenecks
Application
Driver
Primary
/data
Secondary
/data
Secondary
/data
RAM Limits on
single server
CPU Limits on
single server
Network
Bandwidth
Disk I/O

42. 42
Reasons to Shard
Performance
Data locality
Recovery Time
Objective (RTO)

43. Sharded Cluster
Application
mongos mongos mongos
Driver

44. 44
Sharded Cluster
Application
mongos mongos mongos
Driver
Config Server

45. Cloud ManagerOps Manager MongoDB Atlas
Private DBaaS
Compatibility multi-environment
Hybrid DBaaS Public DBaaS
Fully managed
Same codebase, same API & same UI

46. 46
Operational Agility – Atlas - Database as a
Service
Self-service, elastic,
and automated
Secure by defaultGlobal and highly
available
Continuous
backups
Real-time monitoring and
optimization
Cloud agnostic

47. MongoDB Stitch
The Best Way to Work With Data

48. Focus Your Energy Where You Can Make a Difference
App Backend Infrastructure
Core Database Functionality
Storage
Service integrations, data access control
Code that moves the business forward
Managing OS, Scale, Security, Backups, etc.
Time
40%
40%
20%

49. Focus Your Energy Where You Can Make a Difference
App Backend Infrastructure
Core Database Functionality
Storage
Service integrations, data access control
Code that moves the business forward
Managing OS, Scale, Security, Backups, etc.
MongoDB
Atlas
Time
40%
40%
20%

50. Focus Your Energy Where You Can Make a Difference
App Backend Infrastructure
Core Database Functionality
Storage
Service integrations, data access control
Code that moves the business forward
Managing OS, Scale, Security, Backups, etc.
MongoDB
Atlas
MongoDB
Stitch Fully managed
Elastic scale
Highly Available
Secure
Time
40%
40%
20%

51. Focus Your Energy Where You Can Make a Difference
App Backend Infrastructure
Core Database Functionality
Storage
Service integrations, data access control
Code that moves the business forward
Managing OS, Scale, Security, Backups, etc.
MongoDB
Atlas
MongoDB
Stitch Fully managed
Elastic scale
Highly Available
Secure
Customer can focus here
Time
40%
40%
20%

52. Streamlines app development with simple, secure access to data and services from the client with thousands of lines less
code to write and no infrastructure to manage – getting your apps to market faster while reducing operational costs.
Stitch QueryAnywhere
Full power of MongoDB
document model & query
language in frontend code
Fine-grained security
policies through
declarative rules
MongoDB Stitch Serverless Platform Services

53. Streamlines app development with simple, secure access to data and services from the client with thousands of lines less
code to write and no infrastructure to manage – getting your apps to market faster while reducing operational costs.
Stitch QueryAnywhere
Full power of MongoDB
document model & query
language in frontend code
Fine-grained security
policies through
declarative rules
Stitch Functions
Run simple JavaScript
functions in Stitch’s
serverless environment
Power apps with Server-side
logic, or enable Data as a
Service with custom APIs.
MongoDB Stitch Serverless Platform Services

54. Streamlines app development with simple, secure access to data and services from the client with thousands of lines less
code to write and no infrastructure to manage – getting your apps to market faster while reducing operational costs.
Stitch QueryAnywhere
Full power of MongoDB
document model & query
language in frontend code
Fine-grained security
policies through
declarative rules
Stitch Functions
Run simple JavaScript
functions in Stitch’s
serverless environment
Power apps with Server-side
logic, or enable Data as a
Service with custom APIs.
Stitch Triggers
Real-time notifications that
launch functions in response
to changes in the database
Make further database
changes, push data to other
places, or interact with users
MongoDB Stitch Serverless Platform Services

55. Stitch QueryAnywhere
Full power of MongoDB
document model & query
language in frontend code
Fine-grained security
policies through
declarative rules
Stitch Functions
Run simple JavaScript
functions in Stitch’s
serverless environment
Power apps with Server-side
logic, or enable Data as a
Service with custom APIs.
Stitch Mobile Sync
Automatically synchronizes
data between documents
held locally in MongoDB
Mobile and the backend
database
(coming soon)
Streamlines app development with simple, secure access to data and services from the client with thousands of lines less
code to write and no infrastructure to manage – getting your apps to market faster while reducing operational costs.
Stitch Triggers
Real-time notifications that
launch functions in response
to changes in the database
Make further database
changes, push data to other
places, or interact with users
MongoDB Stitch Serverless Platform Services

56. 56
Demo!

57. MongoDB Kubernetes Operator
https://docs.opsmanager.mongodb.com/current/tutorial/install
-k8s-operator/

58. 58
Conclusion
@MBeugnet MaBeuLux88

59. 59
Community is awesome!
https://mongo-db.slack.com
https://mongodb.influitive.com/