Effective ActiveRecord

Effective ActiveRecord
Sam Goldman
@nontrivialzeros
http://github.com/samwgoldman
sam@smartlogic.io

Wednesday, December 18, 13

Review: Models
class User < ActiveRecord::Base
end
foo = User.find(1)
foo.name # "Foo"
foo.email # "foo@example.com"
bar = User.find(2)
bar.name # "Bar
bar.email # "bar@example.com"


users
id

email

name

1 foo@example.com Foo
2 bar@example.com Bar

Review: Has Many
class Project < AR::Base
has_many :members
end
class Member < AR::Base
belongs_to :project
end
foo_project = Project.find(1)
foo_project.name
# "Foo project"
foo_project.members.
map(&:email)
# ["foo@example.com",
# "bar@example.com"]


projects
id

name

1 Foo project
2 Bar project

members
id project_id

email

1

1

foo@example.com

2

1

bar@example.com

3

2

baz@example.com

4

2

quux@example.com

Review: Belongs To
has_many :members
end
belongs_to :project
end
foo = Member.find(1)
foo.email
# "foo@example.com"
foo.project.name
# "Foo project"


projects
id

name

1 Foo project
2 Bar project

members
id project_id

email

1

1

foo@example.com

2

1

bar@example.com

3

2

baz@example.com

4

2

quux@example.com

Review: Has Many Through
class User < AR::Base
has_many :members
has_many :projects,
through: :members
end
has_many :members
end
belongs_to :user
belongs_to :project
end
foo = User.find(1)
foo.projects.map(&:name)
# ["Foo project",
# "Bar project"]


users
id

email

name

1 foo@example.com Foo

projects
id

name

1 Foo project
2 Bar project

members
id project_id

user_id

1

1

1

3

2

1

Creating Records
project = Project.create(name: "Project")
(0.3ms) BEGIN
SQL (1.5ms) INSERT INTO "projects" ("name") VALUES ($1)
RETURNING "id"
[["name", "Project"]]
(0.4ms) COMMIT

user = User.create(name: "User", email: "user@example.com")
(0.3ms) BEGIN
SQL (1.3ms) INSERT INTO "users" ("email", "name") VALUES ($1, $2)
RETURNING "id"
[["email", "user@example.com"], ["name", "User"]]
(0.4ms) COMMIT

member = Member.create(user: user, project: project)
(0.5ms) BEGIN
SQL (3.7ms) INSERT INTO "members" ("project_id", "user_id") VALUES ($1, $2)
RETURNING "id"
[["project_id", 1], ["user_id", 1]]
(0.3ms) COMMIT


Updating Records
project.update_attributes(name: "Updated Project")
(0.2ms) BEGIN
SQL (0.9ms) UPDATE "projects" SET "name" = $1
WHERE "projects"."id" = 1
[["name", "Updated Project"]]
(0.4ms) COMMIT

user.update_attributes(name: "Updated User")
(0.1ms) BEGIN
SQL (0.9ms) UPDATE "users" SET "name" = $1
WHERE "users"."id" = 1
[["name", "Updated User"]]
(0.4ms) COMMIT


Autosave
class Member < ActiveRecord::Base
belongs_to :user
belongs_to :project
end
project = Project.new(name: "Project")
user = User.new(name: "User", email: "user@example.com")
Guess the result.


Autosave
belongs_to :user
belongs_to :project
end
(0.4ms) BEGIN
RETURNING "id"
RETURNING "id"
RETURNING "id"
(0.5ms) COMMIT


Autosave
belongs_to :user
belongs_to :project
end
member = Member.new
member.build_user(name: "User", email: "user@example.com")
member.build_project(name: "Project")
member.save
(0.4ms) BEGIN
RETURNING "id"
RETURNING "id"
RETURNING "id"
(0.5ms) COMMIT


Autosave
belongs_to :user, autosave: false
belongs_to :project, autosave: false
end
member = Member.new
member.save
Guess the result.


Autosave
belongs_to :user, autosave: false
belongs_to :project, autosave: false
end
member = Member.new
member.save
PG::NotNullViolation:
ERROR: null value in column "user_id" violates not-null constraint
(ActiveRecord::StatementInvalid)
DETAIL: Failing row contains (1, null, null).
: INSERT INTO "members" DEFAULT VALUES RETURNING "id"


Autosave
belongs_to :user
belongs_to :project
end
member.user.name = "Updated User"
member.project.name = "Updated Project"
member.save
Guess the result.


Autosave
belongs_to :user
belongs_to :project
end
member.save
(0.2ms) BEGIN
(0.2ms) COMMIT


Autosave
belongs_to :user, autosave: true
belongs_to :project, autosave: true
end
member.save
Guess the result.


Autosave
belongs_to :user, autosave: true
belongs_to :project, autosave: true
end
member.save
(0.2ms) BEGIN
SQL (1.1ms) UPDATE "users" SET "name" = $1
WHERE "users"."id" = 1
[["name", "Updated User"]]
SQL (1.2ms) UPDATE "projects" SET "name" = $1
WHERE "projects"."id" = 1
[["name", "Updated Project"]]
(0.4ms) COMMIT


Autosave
class Project < ActiveRecord::Base
has_many :members
end
project.members << Member.new(user: user)
project.save
Guess the result.


Autosave
has_many :members
end
project.members << Member.new(user: user)
project.save
(0.7ms) BEGIN
RETURNING "id"
RETURNING "id"
RETURNING "id"
(0.5ms) COMMIT


Autosave
has_many :members
end
project.members.build(user: user)
project.save
(0.7ms) BEGIN
RETURNING "id"
RETURNING "id"
RETURNING "id"
(0.5ms) COMMIT


Autosave
has_many :members, autosave: false
end
project.save
Guess the result.


Autosave
has_many :members, autosave: false
end
project.save
(0.4ms) BEGIN
RETURNING "id"
(0.4ms) COMMIT


Inverses
has_many :tasks
end
class Task < ActiveRecord::Base
belongs_to :project
end
task = project.tasks.build
project.save
p project.object_id
p task.project.object_id
Guess the result.


Inverses
has_many :tasks
end
belongs_to :project
end
project.save
p project.object_id

Not just an
extra query. Split
brain!

70236648295560
Project Load (1.4ms) SELECT "projects".* FROM "projects"
WHERE "projects"."id" = $1
ORDER BY "projects"."id" ASC
LIMIT 1
[["id", 1]]
70236645304160


Inverses
has_many :tasks, inverse_of: :project
end
belongs_to :project
end
project.save
p project.object_id
Guess the result.


Inverses
has_many :tasks, inverse_of: :project
end
belongs_to :project
end
project.save
p project.object_id
70259515608140
70259515608140


Summary
• Use autosave and inverse associations
• Inspect the generated SQL for sanity
• Avoid explicit transactions


Authorization
class ProjectMembersController < ApplicationController
# POST /project/:project_id/members
def create
member = Member.create(member_params.merge(project_id: project_id))
respond_with member
end
private
def project_id
params.require(:project_id)
end
def member_params
params.require(:member).permit(:user_id)
end
end


Authorization
def create
member = Member.create(member_params.merge(project_id: project_id))
respond_with member
end

Anyone can
def project_id
add any user to any
end
project!
private

def member_params
end
end


Authorization
def create
member = current_user.create_project_member(project_id, member_params)
respond_with member
end
private
def project_id
end
def member_params
end
end
has_many :members
has_many :projects, through: :members

May only add
members to my own
projects.

def create_project_member(project_id, member_params)
project = projects.find(project_id)
project.members.create(member_params)
end
end


Authorization
def create
member = current_user.build_project_member(project_id, member_params)
member.save
respond_with member
end
private
def project_id
end

Separate build vs.
create

def member_params
end
end
has_many :members
def build_project_member(project_id, member_params)
project.members.build(member_params)
end
end

Authorization
def create
member.save
respond_with member
end
private
def project_id
end
def member_params
end
end

What if I am
not a member of this
has_many :members
project?
end
end

Authorization
Couldn't find Project with id=1
(ActiveRecord::RecordNotFound)


Authorization
has_many :members, inverse_of: :user
project = projects.find_one(project_id)
if project
end
end
end


Authorization
def member(project_id)
members.find_by(project_id: project_id)
end
member = member(project_id)
if member
member.build_project_member(member_params)
end
end
end
belongs_to :user, inverse_of: :members
belongs_to :project, inverse_of: :members
def build_project_member(member_params)
end
end


Authorization
members.find_by(project_id: project_id)
end
member = member(project_id)
if member
end
end
end
if role == "admin"
end
end
end


Authorization
def create
if member.nil?
# handle error
else
member.save
respond_with member
end
end
private
def project_id
end
def member_params
end
end


Authorization
def create
if member.nil?
# handle error
else
member.save
respond_with member
end
end
private

Which error
happened?

def project_id
end
def member_params
end
end


Authorization
Failure = Struct.new(:error) do
def success?
false
end
end
Success = Struct.new(:value) do
def success?
true
end
end
if role == "admin"
Success.new(project.members.build(member_params))
else
Failure.new(:not_authorized)
end
end
end


Authorization
member = members.find_by(project_id: project_id)
if member
Success.new(member)
else
Failure.new(:member_not_found)
end
end
result = member(project_id)
if result.success?
result.value.build_project_member(member_params)
else
result
end
end
end


Authorization
def create
result = current_user.build_project_member(project_id, member_params)
if result.success?
member = result.value
member.save
respond_with member
else
result.error # handle error
end
end
private
def project_id
end
def member_params
end
end


Authorization
alice = User.create(name: "Alice", email: "alice@example.com")
bob = User.create(name: "Bob", email: "bob@example.com")
p alice.build_project_member(project.id, {
user_id: bob.id,
role: "member"
})
#<struct Failure error=:member_not_found>


Authorization
alice.members.create(project: project, role: "member")
user_id: bob.id,
role: "member"
})
#<struct Failure error=:not_authorized>


Authorization
alice.members.create(project: project, role: "admin")
user_id: bob.id,
role: "member"
})
#<struct Success value=#<Member user_id: 2, project_id: 1, role: "member">>


Summary
• Use the relations
• Move beyond ActiveRecord’s API
• Use result objects to represent possible
failures

• Separate building vs. creating APIs

Refactoring
has_many :members
if member
Success.new(member)
else
end
end
if result.success?
else
result
end
end
end


Refactoring
has_many :members
if member
Success.new(member)
else
end
end
if result.success?
else
result
end
end
end


We need a way to
combine results.

Refactoring
Failure = Struct.new(:error) do
def success?
false
end
def map
self
end
def bind
self
end
end


Success = Struct.new(:value) do
def success?
true
end
def map
Success.new(yield value)
end
def bind
yield value
end
end

Refactoring
has_many :members
if member
Success.new(member)
else
end
end

Build compound
results.

member(project_id).bind do |member|
end
end
end


Serialize
if role == "admin"
else
end
end
end


Serialize
serialize :role, Role
role.build_project_member(project, member_params)
end
end


Serialize
class Role
Unknown = Object.new
def Unknown.name
nil
end
MAP = {}
MAP.default = Unknown
def self.load(name)
MAP[name]
end
def self.dump(role)
role.name
end
attr_reader :name
def initialize(name, &block)
@name = name
instance_eval(&block)
MAP[name] = self
end
end


Serialize
class Role
Admin = Role.new("admin") do
def build_project_member(project, member_params)
end
end
Member = Role.new("member") do
end
end
Null = Role.new(nil) do
Failure.new(:missing_role)
end
end
def Unknown.build_project_member(project, member_params)
Failure.new(:unknown_role)
end
end


Authorization
def create
result = current_user.build_project_member(project_id, member_params)
if result.success?
member = result.value
member.save
respond_with member
else
result.error # handle error
end
end
private
def project_id
end
def member_params
member_params = params.require(:member).permit(:user_id, :role)
role = Role.load(member_params[:role].presence)
member_params.merge(:role => role)
end
end


Questions?
http://smartlogic.io
http://twitter.com/smartlogic
http://github.com/smartlogic
http://facebook.com/smartlogic


Effective ActiveRecord

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (18)

Similaire à Effective ActiveRecord

Similaire à Effective ActiveRecord (20)

Plus de SmartLogic

Plus de SmartLogic (20)

Dernier

Dernier (20)

Effective ActiveRecord