ActiveRecord Query Interface (2), Season 2

Ror lab. season 2
- the 11th round -

Active Record
Query Interface (2)

December 1st, 2012

Hyoseong Choi

Eager Loading
Associations
: as few queries as possible

N + 1 queries problem

clients = Client.limit(10)

clients.each do |client|
puts client.address.postcode
end

Eager Loading
Associations
: as few queries as possible

Solution to N + 1 queries problem Only 2 queries

clients = Client.includes(:address).limit(10)

clients.each do |client|
puts client.address.postcode
end

SELECT * FROM clients LIMIT 10
SELECT addresses.* FROM addresses
WHERE (addresses.client_id IN (1,2,3,4,5,6,7,8,9,10))

Eager Loading
Associations
- Eager Loading Multiple Associations -
Array of Multiple Associations

Post.includes(:category, :comments)

Nested Associations Hash

Category.includes(
:posts => [{:comments => :guest}, :tags]).find(1)

Eager Loading
Associations
- Conditions on Eager Loaded Associations -

conditional “joins” > conditional “includes”

Post.includes(:comments)
.where("comments.visible", true)

SELECT "posts"."id" AS t0_r0, ... "comments"."updated_at" AS t1_r5
FROM "posts"
LEFT OUTER JOIN "comments"
ON "comments"."post_id" = "posts"."id"
WHERE (comments.visible = 1)

Eager Loading
Associations
- Conditions on Eager Loaded Associations -
INNER JOIN LEFT OUTER JOIN
conditional “joins” > conditional “includes”

Post.includes(:comments)
.where("comments.visible", true)

SELECT "posts"."id" AS t0_r0, ... "comments"."updated_at" AS t1_r5
FROM "posts"
LEFT OUTER JOIN "comments"
ON "comments"."post_id" = "posts"."id"
WHERE (comments.visible = 1)

Scopes

• ToSQL AST(Abstract Syntax Tree) manger for Ruby
:a
specify ARel queries

• Referenced as method calls on the
association objects or model
• ﬁnder methods in a scope
• return an ActiveRecord::Relation object

Scopes

class Post < ActiveRecord::Base
scope :published, where(:published => true)
end
ARel query

Scopes
chainable
  scope :published,
where(:published => true).joins(:category)
end

chainable within scopes
  scope :published, where(:published => true)
  scope :published_and_commented,
published.and(self.arel_table[:comments_count].gt(0))
end

Scopes
To call the scope

Post.published # => [published posts]

category = Category.first
category.posts.published
# => [published posts belonging to this category]

Scopes
Working with times

scope :last_week,
lambda { where("created_at < ?", Time.zone.now ) }
end
a lambda so that the scope is evaluated every time

Scopes
Passing in arguments
  scope :1_week_before,
lambda { |time| where("created_at < ?", time) }
end

Post.1_week_before(Time.zone.now)

  def self.1_week_before(time)
    where("created_at < ?", time)
  end
end ***What about “as a class method” ?

Scopes
  scope :1_week_before,
lambda { |time| where("created_at < ?", time) }
end

Post.1_week_before(Time.zone.now)

b le
r ea
e fe class Post < ActiveRecord::Base
pr   def self.1_week_before(time)
    where("created_at < ?", time)
  end
end ***What about “as a class method” ?

Scopes

category.posts.1_week_before(time)

Scopes
Working with Scopes

client = Client.find_by_first_name("Ryan")
orders = client.orders.scoped

orders.where("created_at > ?", 30.days.ago)

Scopes
Applying a default scope

class Client < ActiveRecord::Base
default_scope where("removed_at IS NULL")
end

SELECT * FROM clients WHERE removed_at IS NULL

Scopes
Removing all scopes

Client.unscoped.all

Especially useful,
when escaping the default_scope

Dynamic Finders
• Model.find_by_attribute_name
• Model.find_all_by_attribute_name
• Model.find_last_by_attribute_name
• Model.find_by_attribute_name!
• Model.find_by_attr1_and_attr2
Rails 3.2 => Argument Error on missing fields

Find or build
a new object

• first_or_create
• first_or_create! Exception on invalid

• first_or_initialize

Find or build
a new object
• ﬁrst_or_create
Client.where(:first_name =>
'Andy').first_or_create(:locked => false)
# => #<Client id: 1, first_name: "Andy", orders_count: 0, locked: false,
created_at: "2011-08-30 06:09:27", updated_at: "2011-08-30 06:09:27">

Client.find_or_create_by_first_name(:first_name =>
"Andy", :locked => false)

SELECT * FROM clients WHERE (clients.first_name = 'Andy') LIMIT 1
BEGIN
INSERT INTO clients (created_at, first_name, locked, orders_count, updated_at)
VALUES ('2011-08-30 05:22:57', 'Andy', 0, NULL, '2011-08-30 05:22:57')
COMMIT

Find or build
a new object
• ﬁrst_or_create!
class Client < ActiveRecord::Base
validates :orders_count, :presence => true
end

Client.where(:first_name => 'Andy').first_or_create!
(:locked => false)
# => ActiveRecord::RecordInvalid: Validation failed: Orders
count can't be blank

Find or build
a new object
• ﬁrst_or_initialize
nick = Client.where(:first_name =>
'Nick').first_or_initialize(:locked => false)
# => <Client id: nil, first_name: "Nick", orders_count: 0,
locked: false, created_at: "2011-08-30 06:09:27", updated_at:
"2011-08-30 06:09:27">

SELECT * FROM clients WHERE (clients.first_name = 'Nick') LIMIT 1

nick.persisted?
# => false
nick.new_record?
# => true
nick.save
# => true

persisted? vs new_record?

Finding by SQL
: return an array of objects
where each object indicates a record

Client.find_by_sql("SELECT * FROM clients
INNER JOIN orders ON clients.id = orders.client_id
ORDER clients.created_at desc")

cf. connection.select_all
an array of hash

select_all
: return an array of hash
where each hash indicates a record

Client.connection.select_all("SELECT * FROM clients
WHERE id = '1'")

cf. ﬁnd_by_sql => instantiates objects

pluck
To query a single column from the underlying table of a model
To return an array of values

Client.where(:active => true).pluck(:id)
# SELECT id FROM clients WHERE active = 1

Client.uniq.pluck(:role)
# SELECT DISTINCT role FROM clients

Client.select(:id).map { |c| c.id }

Client.pluck(:id)

Existence of
Objects
Client.exists?(1)

Client.exists?(1,2,3)
# or
Client.exists?([1,2,3])

Client.where(:first_name => 'Ryan').exists?

Client.exists?

cf. ﬁnd method

Existence of
Objects
# via a model
Post.any?
Post.many?

# via a named scope
Post.recent.any?
Post.recent.many?

# via a relation
Post.where(:published => true).any?
Post.where(:published => true).many?

# via an association
Post.first.categories.any?
Post.first.categories.many?

Calculations
Client.count
# SELECT count(*) AS count_all FROM clients

Client.where(:first_name => 'Ryan').count
# SELECT count(*) AS count_all FROM clients WHERE
(first_name = 'Ryan')

Client.includes("orders").where(:first_name =>
'Ryan', :orders => {:status => 'received'}).count

SELECT count(DISTINCT clients.id) AS count_all FROM clients
LEFT OUTER JOIN orders ON orders.client_id = client.id WHERE
(clients.first_name = 'Ryan' AND orders.status = 'received')

Calculations
Client.count(:age)

Client.average("orders_count")

Client.minimum("age")

Client.maximum("age")

Client.sum("orders_count")

Running EXPLAIN
a pretty printing that emulates the one of the database shells

User.where(:id => 1).joins(:posts).explain

EXPLAIN for: SELECT "users".* FROM "users" INNER JOIN "posts" ON "posts"."user_id" = "users"."id"
WHERE "users"."id" = 1
                                  QUERY PLAN
------------------------------------------------------------------------------
Nested Loop Left Join (cost=0.00..37.24 rows=8 width=0)
   Join Filter: (posts.user_id = users.id)
   -> Index Scan using users_pkey on users (cost=0.00..8.27 rows=1 width=4)
         Index Cond: (id = 1)
   -> Seq Scan on posts (cost=0.00..28.88 rows=8 width=4)
         Filter: (posts.user_id = 1)
(6 rows)

under PostgreSQL

Running EXPLAIN
Eager Loading

User.where(:id => 1).includes(:posts).explain

EXPLAIN for: SELECT ùsers`.* FROM ùsers` WHERE ùsers`.ìd` = 1
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
| 1 | SIMPLE      | users | const | PRIMARY       | PRIMARY | 4       | const |    1 |       |
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
1 row in set (0.00 sec)

EXPLAIN for: SELECT `posts`.* FROM `posts` WHERE `posts`.ùser_id` IN (1)
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
| 1 | SIMPLE      | posts | ALL | NULL          | NULL | NULL    | NULL |    1 | Using where |
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
1 row in set (0.00 sec)

under MySQL

Running EXPLAIN
Automatic EXPLAIN

To set the threshold in seconds
config.active_record.auto_explain_threshold_in_seconds

• disables automatic EXPLAIN => nil or no AR logger
• Development mode => default, 0.5 sec
• Test mode => nil
• Production mode => nil

Running EXPLAIN
Disabling Automatic EXPLAIN

To be selectively silenced with
ActiveRecord::Base.silence_auto_explain do
# no automatic EXPLAIN is triggered here
end

• useful for queries are slow but ﬁne
: a heavyweight report of a admin interface

ActiveRecord Query Interface (2), Season 2

More Related Content

What's hot (20)

Similar to ActiveRecord Query Interface (2), Season 2 (20)

More from RORLAB (20)

Recently uploaded (20)

ActiveRecord Query Interface (2), Season 2