Getting started with


MongoDB
Introduction
Introduction
Relational
Database
Introduction
                            Document
Relational
                            Orientated
Database
                            Database
Introduction
                             Document
Relational
                             Orientated
Database
                             Database




                NoSQL Bra.
What is MongoDB?

•   Scalable high-performance open source, document-
    orientated database
•   Built for speed
•   Rich document based queries
•   Full index support
•   Replication and Failover
•   Auto Sharding
•   Map / Reduce
Why use MongoDB?


•   SQL was invented in the 70’s to store data
•   MongoDB stores documents / objects
•   We work with objects (Ruby)
•   We need databases to persist our objects
•   So why not just store objects directly?
What its great for


•   Websites
•   Caching
•   High scalability
•   Storage of program objects and JSON
What its not great for


•   Highly transactional applications
•   Problems requiring SQL
Differences
When I Say

Database
When I Say     Think

Database     Database
When I Say                               Think

    Database                             Database


•   Made up of multiple collections
•   Are created on-the-fly when first referenced
When I Say

Collection
When I Say   Think

Collection    Table
When I Say                               Think

    Collection                                 Table

•   Schema-less
•   Indexable by one or more keys
•   Created on-the-fly when first referenced
•   Capped collections: Fixed size, older records dropped after
    limit reached
When I Say

Document
When I Say       Think

Document      Record / Row
When I Say                              Think

    Document                        Record / Row

•   Stored in a collection
•   Can have _id key - Works like primary keys in MySQL
•   Supports relationships: embedded or referential
•   Document storage in BSON
When I Say                               Think

    Document                         Record / Row

•   Stored in a collection
•   Can have _id key - Works like primary keys in MySQL
•   Supports relationships: embedded or referential
•   Document storage in BSON

                               JSONS Binary Brother
Relations
Referential / Normalised


•   Same as SQL
•   “First class” objects that are at top level
•   Many to many relationships




                               has_many
                     User                   Blog Post
                               belongs_to
# Post
                               {

                                   title: “Getting started with MongoDB”,

                                   body: “blah blah blah ... “,

                                   created: Date(’09-06-2010’),

                                   tags: [1, 2]

                               }




# Comments                                                                  # Tags
                                                                            {
{
                                                                                 id: 1,
    body: “I did not have relations..”,
                                                                                 name: “example”
    user_id: 1,
                                                                            },
                                                                            {
    post_id: 1,
                                                                                 id: 2,
    created: Date(’09-06-2010’),
                                                                                 name: “lol”
}
                                                                            }
Embedded


•   Embedded is pre-joining
•   Embed when document always appears with parent
•   4MB document size limit



                              Blog Post

                               Post Title
                               Post Body




                              Comments
# Posts
        {
            title: “Getting started with MongoDB”,

            body: “blah blah blah ... “,

            created: Date(’09-06-2010’),

Array       tags: [ ‘example’, ‘bill clinton’ ],

            comments: [
              { author: “Bill”, comment: “I did not have relations” },
              { author: “Monica”, comment: “LOL” }
            ]
        }
                                                                         Array of hashes
Ruby   MongoDB
MongoMapper
              http://github.com/jnunemaker/mongomapper




•   Typecasting
•   Callbacks (ActiveSupport Callbacks)
•   Validations
•   Connection and database can differ per document
•   Has create, update methods
•   Find: id, ids, :all, :first, :last
•   Associations (has_one, has_many, many_to_many)
http://www.mongoid.org




•   Named scopes / chainable criteria
•   Versioning of your documents
•   Full callback support on documents AND embedded
    documents
•   Proper master/slave distribution
•   Optimised for use with extremely large datasets


                                              This is what we use!
Demo
Conclusions




•   NoSQL is pretty scary / We’re used to SQL
•   It’s the future.
Chat to us online:



twitter: @platform45
Discussion

Introduction to MongoDB

  • 2.
  • 3.
  • 4.
  • 5.
    Introduction Document Relational Orientated Database Database
  • 6.
    Introduction Document Relational Orientated Database Database NoSQL Bra.
  • 7.
    What is MongoDB? • Scalable high-performance open source, document- orientated database • Built for speed • Rich document based queries • Full index support • Replication and Failover • Auto Sharding • Map / Reduce
  • 8.
    Why use MongoDB? • SQL was invented in the 70’s to store data • MongoDB stores documents / objects • We work with objects (Ruby) • We need databases to persist our objects • So why not just store objects directly?
  • 9.
    What its greatfor • Websites • Caching • High scalability • Storage of program objects and JSON
  • 10.
    What its notgreat for • Highly transactional applications • Problems requiring SQL
  • 11.
  • 12.
  • 13.
    When I Say Think Database Database
  • 14.
    When I Say Think Database Database • Made up of multiple collections • Are created on-the-fly when first referenced
  • 15.
  • 16.
    When I Say Think Collection Table
  • 17.
    When I Say Think Collection Table • Schema-less • Indexable by one or more keys • Created on-the-fly when first referenced • Capped collections: Fixed size, older records dropped after limit reached
  • 18.
  • 19.
    When I Say Think Document Record / Row
  • 20.
    When I Say Think Document Record / Row • Stored in a collection • Can have _id key - Works like primary keys in MySQL • Supports relationships: embedded or referential • Document storage in BSON
  • 21.
    When I Say Think Document Record / Row • Stored in a collection • Can have _id key - Works like primary keys in MySQL • Supports relationships: embedded or referential • Document storage in BSON JSONS Binary Brother
  • 22.
  • 23.
    Referential / Normalised • Same as SQL • “First class” objects that are at top level • Many to many relationships has_many User Blog Post belongs_to
  • 24.
    # Post { title: “Getting started with MongoDB”, body: “blah blah blah ... “, created: Date(’09-06-2010’), tags: [1, 2] } # Comments # Tags { { id: 1, body: “I did not have relations..”, name: “example” user_id: 1, }, { post_id: 1, id: 2, created: Date(’09-06-2010’), name: “lol” } }
  • 25.
    Embedded • Embedded is pre-joining • Embed when document always appears with parent • 4MB document size limit Blog Post Post Title Post Body Comments
  • 26.
    # Posts { title: “Getting started with MongoDB”, body: “blah blah blah ... “, created: Date(’09-06-2010’), Array tags: [ ‘example’, ‘bill clinton’ ], comments: [ { author: “Bill”, comment: “I did not have relations” }, { author: “Monica”, comment: “LOL” } ] } Array of hashes
  • 27.
    Ruby MongoDB
  • 28.
    MongoMapper http://github.com/jnunemaker/mongomapper • Typecasting • Callbacks (ActiveSupport Callbacks) • Validations • Connection and database can differ per document • Has create, update methods • Find: id, ids, :all, :first, :last • Associations (has_one, has_many, many_to_many)
  • 29.
    http://www.mongoid.org • Named scopes / chainable criteria • Versioning of your documents • Full callback support on documents AND embedded documents • Proper master/slave distribution • Optimised for use with extremely large datasets This is what we use!
  • 30.
  • 31.
    Conclusions • NoSQL is pretty scary / We’re used to SQL • It’s the future.
  • 32.
    Chat to usonline: twitter: @platform45
  • 33.

Editor's Notes

  • #4 Old man - SQL DoD - MongoDB
  • #5 Old man - SQL DoD - MongoDB
  • #6 Old man - SQL DoD - MongoDB
  • #7 Document Orientated: It isnt stored as records and tables, information stored as documents or objects Build for speed: No transaction log / removed anything that would slow it down Rich document based queries: Users can find documents based on any search criteria / similar to SQL Full index support: Index on any attribute - similar to SQL Replication and failover: Supports replication of data between servers for failover and redundancy Auto sharding: Scale horizontally without compromising functionality - EVERY EASY - NO JOINS Map Reduce - Database itself can perform advanced aggregation and data processing
  • #9 Websites: Object orientated programming languages - Easy persistence of objects Caching: Extremely fast High scalability: Easy Auto sharding and replication and failover
  • #10 * SQL writes to transaction log (for data durability) * Performance loss * MongoDB doesn’t do this - Uses replication
  • #11 Similarities and Differences between SQL and document orientated databases
  • #12 No need for any rake db:creates or rake db:setup
  • #13 No need for any rake db:creates or rake db:setup
  • #14 Like a table in MySQL EXCEPT!!! Capped collections: Extremely fast, atomic writes, good for log files
  • #15 Like a table in MySQL EXCEPT!!! Capped collections: Extremely fast, atomic writes, good for log files
  • #19 Next up is relations - which is one of the major differences or advantages over SQL
  • #20 First class - objects that can stand alone (users -> blog posts)
  • #21 Similar to MySQL Tags: Array of ID’s Many to many Comments: belongs_to / has_many
  • #24 Using mongodb with ruby
  • #25 First up: Mongomapper by jnunemaker Works for OrderedList Typecasting: Mongodb doesnt understand types - MongoMapper creates the typecasting
  • #26 Durran - Hashrocket