Tame Accidental Complexity with Ruby and MongoMapper

Tame accidental complexity
Introduction to NoSQL with MongoMapper

Giordano Scalzo

I’m not here to talk about performance

I’m not here to talk about scalability

but I’m here to talk about simplicity

Anatomy of a Rails Application


view


view controller


view controller model

Diﬀerent languages
html+css


html+css oop


html+css oop sql


Impedance mismatch
html+css oop sql


Origin of Sql

SQL
From Wikipedia, the free encyclopedia

SQL (...), is a database computer language
designed for managing data in relational
database management systems (RDBMS)

We need persistent objects!

class User
def initialize(username, password)
@username = username
@password = password
end
end

We need persistent objects!

{
username: "giordano",
password: "123"
}

Persistence

class User
include MongoMapper::Document
end

Persistence

class User
end

user = User.create({
:username => "giordano",
:password => "123"
})
user.save

Persistence

class User
end

user = User.create({
:username => "giordano",
:password => "123"
})
user.save

puts User.all.last.to_mongo

Persistence

{
"_id"=>BSON::ObjectId('4d643a274d8ff683dd000001'),
"username"=>"giordano",
"password"=>"123"
}

Types

class User
key :username, String
key :password , String
end

Built-in Types

Array, Binary, Boolean, Date,
Float, Hash, Integer, Nil,
ObjectId, Set, String, Time

Custom Types

class DowncasedString
def self.to_mongo(value)
value.nil? ? nil : value.to_s.downcase
end
def self.from_mongo(value)
value.nil? ? nil : value.to_s.downcase
end
end

Custom Types

class User
key :email, DowncasedString
end

Custom Types

user = User.new
user.username = "giordano"
user.password = "123"
user.email = "Giordano.Scalzo@CleanCode.it"

user.save

puts User.all.last.to_mongo

Custom Types

{
"_id"=>BSON::ObjectId('4d6442d94d8ff684d3000001'),
"username"=>"giordano", "password"=>"123",
"email"=>"giordano.scalzo@cleancode.it"
}

Embedded Documents

class Task
include MongoMapper::EmbeddedDocument
key :description, String
key :pomodori, Integer
key :is_done, Boolean
end

Embedded Documents

class User
key :email, DowncasedString
many :tasks
end

Embedded Documents

user.tasks << Task.new({
description: 'refactor server',
pomodori: 8,
is_done: false
})

user.tasks << Task.new({
description: 'timer sound',
pomodori: 2,
is_done: false
})

Embedded Documents
{
"_id"=>BSON::ObjectId('4d6575e84d8ff692e6000001'),
"email"=>"giordano.scalzo@cleancode.it",
"tasks"=>[{
"description"=>"refactor server",
"pomodori"=>8, "is_done"=>false
}, {
"description"=>"timer sound",
"pomodori"=>2, "is_done"=>false
}]
}

Documents

class Task
key :description, String
key :pomodori, Integer
key :is_done, Boolean
end

Documents

p User.all.last.to_mongo

{
"_id"=>BSON::ObjectId('4d657e924d8ff6949c000001'),
"email"=>"giordano.scalzo@cleancode.it"
}

Documents

p User.all.last.tasks
[#<Task _id:
BSON::ObjectId('4d65822b4d8ff69542000002'),
description: "refactor server",
pomodori: 8, is_done: false,
user_id: BSON::ObjectId('4d65822b4d8ff69542000001')
>,
#<Task _id:
BSON::ObjectId('4d65822b4d8ff69542000003'),
description: "timer sound",
pomodori: 2, is_done: false,
user_id: BSON::ObjectId('4d65822b4d8ff69542000001')
>
]

Validations & Callbacks

class User
key :username, String,
validates_presence_of :username
key :password, String
validates_presence_of :password
end


class User
key :username, String, :required => true
key :password, String, :required => true
end


validates_presence_of
validates_length_of
validates_format_of
validates_numericality_of
validates_acceptance_of
validates_confirmation_of
validates_inclusion_of
validates_exclusion_of


before_save after_save
before_create after_create
before_update after_update
before_validation after_validation
before_validation_on_create after_validation_on_create
before_validation_on_update after_validation_on_update
before_destroy after_destroy
validate_on_create validate_on_update
validate


forked in current gem 0.8.6
using Rails3 ActiveModel in
Rails3 branch just merged

What about querying?

query = User.where(:last_name.exists => true,
:created_at.gte => from_date,
:created_at.lt => Time.now)
Plucky: ActiveRecord-like language
.skip(0).limit(5)

query.all


query = User.where(:last_name.exists => true,
:created_at.gte => from_date,
:created_at.lt => Time.now)
.skip(0).limit(5)
#<Plucky::Query created_at: {
"$gte"=>"1",
"$lt"=>2011-02-24 10:54:36 UTC},
last_name: {"$exists"=>true}, limit: 5, skip: 0>


query = User.where(:last_name.exists => true)
.where(:created_at.gte => from_date)
.where(:created_at.lt => Time.now)
.skip(0).limit(5)
#<Plucky::Query created_at: {
"$gte"=>"1",
"$lt"=>2011-02-24 10:54:36 UTC},
last_name: {"$exists"=>true}, limit: 5, skip: 0>

What about plugins?
Accessible Modifiers
Associations Pagination
Caching Persistence
Callbacks Protected
Clone Querying
Dirty Rails
Document Safe
Dynamic Querying Single
EmbeddedDocument Collection
Equality Inheritance
IdentityMap Scopes
Indexes Serialization
Inspect Timestamps
Keys Userstamps
Logger Validations

http://mongomapper.com/documentation/

giordano.scalzo@cleancode.it
@giordanoscalzo
www.slideshare.net/giordano
github.com/gscalzo

Tame Accidental Complexity with Ruby and MongoMapper

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (6)

Similar to Tame Accidental Complexity with Ruby and MongoMapper

Similar to Tame Accidental Complexity with Ruby and MongoMapper (20)

More from Giordano Scalzo

More from Giordano Scalzo (10)

Tame Accidental Complexity with Ruby and MongoMapper