The document summarizes ActiveRecord query methods in Ruby on Rails. It discusses finder methods like where, select, group, order, limit, and offset for retrieving single or multiple records. It also covers retrieving objects in batches, conditions like string, array, and hash conditions, ordering, selecting specific attributes, limiting, grouping, having, and overriding conditions.

1. The 9th Round of ROR Lab.
Active Record
Query Interface(1)
March 17th, 2012
Hyoseong Choi
ROR Lab.

2. ActiveRecord
• No more SQL statements MySQL
PostgreSQL
: select * from tables SQLite
...
ORM
Active
• SQL query Record
• Fire Finder
• Ruby object Methods
• after_find callback
ROR Lab.

3. Finder Methods of
ActiveRecord
1.where
2.select
3.group
4.order
5.reorder
6.reverse_order
7.limit
8.offset
9.joins
10.includes
11.lock
12.readonly
13.from
14.having
ActiveRecord::Relation
ROR Lab.

4. Retrieving
A Single Object
• find
• first
• last
• first!
• last!
ROR Lab.

5. Retrieving
A Single Object
- find -
# Find the client with primary key (id) 10.
client = Client.find(10)
# => #<Client id: 10, first_name: "Ryan">
SELECT * FROM clients WHERE (clients.id = 10)
ActiveRecord::RecordNotFound exception
ROR Lab.

6. Retrieving
A Single Object
- first -
client = Client.first
# => #<Client id: 1, first_name: "Lifo">
SELECT * FROM clients LIMIT 1
nil if no matching record is found
ROR Lab.

7. Retrieving
A Single Object
- last -
client = Client.last
# => #<Client id: 221, first_name: "Russel">
SELECT * FROM clients ORDER BY clients.id DESC LIMIT 1
nil if no matching record is found
ROR Lab.

8. Retrieving
A Single Object
- first! -
client = Client.first!
# => #<Client id: 1, first_name: "Lifo">
SELECT * FROM clients LIMIT 1
RecordNotFound if no matching record
ROR Lab.

9. Retrieving
A Single Object
- last! -
client = Client.last!
# => #<Client id: 221, first_name: "Russel">
SELECT * FROM clients ORDER BY clients.id DESC LIMIT 1
RecordNotFound if no matching record
ROR Lab.

10. Retrieving
Multiple Objects
• Using multiple primary keys
• In batches
• find_each :batch_size, :start,
• find_in_batches :batch_size, :start
+ find options (except for :order, :limit)
ROR Lab.

11. Retrieving
Multiple Objects
- Using multiple primary keys -
# Find the clients with primary keys 1 and 10.
client = Client.find([1, 10])
# Or even Client.find(1, 10)
# => [#<Client id: 1, first_name: "Lifo">,
#<Client id: 10, first_name: "Ryan">]
SELECT * FROM clients WHERE (clients.id IN (1,10))
ActiveRecord::RecordNotFound exception
ROR Lab.

12. Retrieving
Multiple Objects
- in Batches -
to iterate over a large set of records
• find_each : each record to the block individually as a model
• find_in_batches : the entire batch to the block as an array of models
# This is very inefficient when the users table
has thousands of rows.
User.all.each do |user|
NewsLetter.weekly_deliver(user)
end
OK to 1,000
ROR Lab.

13. Retrieving
Multiple Objects
- in Batches : find_each -
User.find_each do |user|
NewsLetter.weekly_deliver(user)
end
User.find_each(:batch_size => 5000) do |user|
NewsLetter.weekly_deliver(user)
end
User.find_each(:start => 2000, :batch_size => 5000)
do |user|
NewsLetter.weekly_deliver(user)
end
ROR Lab.

14. Retrieving
Multiple Objects
- in Batches : find_each -
Article.find_each { |a| ... } # => iterate over all
articles, in chunks of 1000 (the default)
Article.find_each(:conditions => { :published =>
true }, :batch_size => 100 ) { |a| ... }
# iterate over published articles in chunks of
100
http://archives.ryandaigle.com/articles/
2009/2/23/what-s-new-in-edge-rails-batched-find
ROR Lab.

15. Retrieving
Multiple Objects
- in Batches : find_in_batches -
# Give add_invoices an array of 1000 invoices at a
time
Invoice.find_in_batches(:include => :invoice_lines)
do |invoices|
export.add_invoices(invoices)
end
options :
• :batch_size & :start
• options of find method (except :order and :limit)
ROR Lab.

16. Retrieving
Multiple Objects
- in Batches : find_in_batches -
Article.find_in_batches { |articles| articles.each { |
a| ... } } # => articles is array of size 1000
Article.find_in_batches(:batch_size => 100 ) { |articles|
articles.each { |a| ... } }
# iterate over all articles in chunks of 100
class Article < ActiveRecord::Base
scope :published, :conditions => { :published => true }
end
Article.published.find_in_batches(:batch_size => 100 )
{ |articles| ... }
# iterate over published articles in chunks of 100
ROR Lab.

17. Conditions
- where -
• String conditions
• Array conditions
• Hash conditions
ROR Lab.

18. String Conditions
Client.where("orders_count = ‘2’")
ROR Lab.

19. Array Conditions
Client.where("orders_count = ?", params[:orders])
Client.where("orders_count = ? AND locked = ?",
params[:orders], false)
X
Client.where("orders_count = #{params[:orders]}")
hacking!!! by SQL injection
http://guides.rubyonrails.org/security.html#sql-injection
ROR Lab.

20. Array Conditions
- Placeholder conditions -
Client.where("created_at >= :start_date AND
created_at <= :end_date", {:start_date =>
params[:start_date], :end_date =>
params[:end_date]})
ROR Lab.

21. Array Conditions
- Range conditions -
Client.where(:created_at =>
(params[:start_date].to_date)..
(params[:end_date].to_date))
SELECT "clients".* FROM "clients" WHERE
("clients"."created_at" BETWEEN '2010-09-29' AND
'2010-11-30')
ROR Lab.

22. Hash Conditions
- Equality conditions -
Client.where(:locked => true)
Client.where('locked' => true)
ROR Lab.

23. Hash Conditions
- Range conditions -
Client.where(:created_at => (Time.now.midnight -
1.day)..Time.now.midnight)
SELECT * FROM clients WHERE (clients.created_at
BETWEEN '2008-12-21 00:00:00' AND '2008-12-22
00:00:00')
ROR Lab.

24. Hash Conditions
- Subset conditions -
Client.where(:orders_count => [1,3,5])
SELECT * FROM clients WHERE (clients.orders_count IN
(1,3,5))
ROR Lab.

25. Ordering
Client.order("created_at")
Client.order("created_at DESC")
# OR
Client.order("created_at ASC")
Client.order("orders_count ASC, created_at DESC")
ROR Lab.

26. Selecting
If the select method is used, all the returning objects will be read only.
Client.select("viewable_by, locked")
SELECT viewable_by, locked FROM clients
ActiveModel::MissingAttributeError: missing attribute: <attribute>
Client.select(:name).uniq
SELECT DISTINCT name FROM clients
query = Client.select(:name).uniq
# => Returns unique names
query.uniq(false)
# => Returns all names, even if there are duplicates
ROR Lab.

27. Limit & Offset
Client.limit(5)
SELECT * FROM clients LIMIT 5
Client.limit(5).offset(30)
SELECT * FROM clients LIMIT 5 OFFSET 30
ROR Lab.

28. Group
Order.select(
"date(created_at) as ordered_date, sum(price) as
total_price")
.group("date(created_at)")
SQL
SELECT date(created_at) as ordered_date, sum(price)
as total_price FROM orders GROUP BY
date(created_at)
ROR Lab.

29. Having
Order.select(
"date(created_at) as ordered_date, sum(price) as
total_price")
.group("date(created_at)")
.having("sum(price) > ?", 100)
SQL
SELECT date(created_at) as ordered_date, sum(price)
as total_price FROM orders GROUP BY
date(created_at) HAVING sum(price) > 100
ROR Lab.

30. Overriding
Conditions
• except
• only
• reorder
• reverse_order
ROR Lab.

31. Overriding
Conditions
- except -
Post.where('id > 10').limit(20).order('id asc').except(:order)
SELECT * FROM posts WHERE id > 10 LIMIT 20
ROR Lab.

32. Overriding
Conditions
- only -
Post.where('id > 10').limit(20).order('id desc').only(:order, :where)
SELECT * FROM posts WHERE id > 10 ORDER BY id DESC
ROR Lab.

33. Overriding
Conditions
- reorder -
class Post < ActiveRecord::Base
..
..
has_many :comments, :order => 'posted_at DESC'
end
Post.find(10).comments.reorder('name')
SELECT * FROM posts WHERE id = 10 ORDER BY name
SELECT * FROM posts WHERE id = 10 ORDER BY posted_at DESC
ROR Lab.

34. Overriding
Conditions
- reverse_order -
Client.where("orders_count > 10").order(:name).reverse_order
SELECT * FROM clients WHERE orders_count > 10 ORDER BY name DESC
Client.where("orders_count > 10").reverse_order
SELECT * FROM clients WHERE orders_count > 10 ORDER BY
clients.id DESC
ROR Lab.

35. Readonly Objects
client = Client.readonly.first
client.visits += 1
client.save
ActiveRecord::ReadOnlyRecord exception
ROR Lab.

36. Locking Records
for Update
• To prevent “race conditions”
• To ensure “atomic updates”
• Two locking mechanisms
‣ Optimistic Locking : version control
‣ Pessimistic Locking : DB lock
ROR Lab.

37. Optimistic Locking
• “lock_version” in DB table (default to 0)
• set_locking_column to change column name
c1 = Client.find(1)
c2 = Client.find(1)
c1.first_name = "Michael"
c1.save # increments the lock_version column
c2.name = "should fail"
c2.save # Raises an ActiveRecord::StaleObjectError
ROR Lab.

38. Optimistic Locking
• To turn off,
ActiveRecord::Base.lock_optimistically = false
• To override the name of the lock_version
column
class Client < ActiveRecord::Base
set_locking_column :lock_client_column
end
ROR Lab.

39. Pessimistic Locking
• A locking mechanism by DB
• An exclusive lock on the selected rows
• Usually wrapped inside a transaction
• Two types of Lock
‣ FOR UPDATE (default, an exclusive lock)
‣ LOCK IN SHARE MODE
ROR Lab.

40. Pessimistic Locking
Item.transaction do
i = Item.lock.first
i.name = 'Jones'
i.save
end
SQL (0.2ms) BEGIN
Item Load (0.3ms) SELECT * FROM `items` LIMIT 1 FOR UPDATE
Item Update (0.4ms) UPDATE `items` SET `updated_at` =
'2009-02-07 18:05:56', `name` = 'Jones' WHERE `id` = 1
SQL (0.8ms) COMMIT
ROR Lab.

41. Pessimistic Locking
Item.transaction do
i = Item.lock("LOCK IN SHARE MODE").find(1)
i.increment!(:views)
end
item = Item.first
item.with_lock do
# This block is called within a transaction,
# item is already locked.
item.increment!(:views)
end
ROR Lab.

42. Joining Tables
- Using a String SQL Fragment -
Client.joins('LEFT OUTER JOIN addresses ON
addresses.client_id = clients.id')
SELECT clients.*
FROM clients
LEFT OUTER JOIN addresses
ON addresses.client_id = clients.id
ROR Lab.

43. Joining Tables
- Using Array/Hash of Named Associations -
only with INNER JOIN
• a Single Association
• Multiple Associations
• Nested Associations(Single Level)
• Nested Associations(Multiple Level)
ROR Lab.

44. Joining Tables
- Using Array/Hash of Named Associations -
only with INNER JOIN
class Category < ActiveRecord::Base
has_many :posts
end
class Post < ActiveRecord::Base • a Single Association
belongs_to :category
has_many :comments
has_many :tags
end Category.joins(:posts)
class Comment < ActiveRecord::Base
belongs_to :post
has_one :guest
end SELECT categories.*
FROM categories
class Guest < ActiveRecord::Base
INNER JOIN posts
belongs_to :comment
end ON posts.category_id = categories.id
class Tag < ActiveRecord::Base
belongs_to :post “return a Category object for all categories with posts”
end
ROR Lab.

45. Joining Tables
- Using Array/Hash of Named Associations -
only with INNER JOIN
class Category < ActiveRecord::Base
has_many :posts
end
class Post < ActiveRecord::Base • Multiple Associations
belongs_to :category
has_many :comments
has_many :tags
end Post.joins(:category, :comments)
class Comment < ActiveRecord::Base
belongs_to :post
has_one :guest
SELECT posts.* FROM posts
end
INNER JOIN categories
class Guest < ActiveRecord::Base ON posts.category_id = categories.id
belongs_to :comment INNER JOIN comments
end ON comments.post_id = posts.id
class Tag < ActiveRecord::Base
“return all posts that have a category and at least one comment”
belongs_to :post
end
ROR Lab.

46. Joining Tables
- Using Array/Hash of Named Associations -
only with INNER JOIN
class Category < ActiveRecord::Base
has_many :posts
end
class Post < ActiveRecord::Base • Nested Associations(Single Level)
belongs_to :category
has_many :comments
has_many :tags
end Post.joins(:comments => :guest)
class Comment < ActiveRecord::Base
belongs_to :post
has_one :guest
SELECT posts.* FROM posts
end
INNER JOIN comments
class Guest < ActiveRecord::Base ON comments.post_id = posts.id
belongs_to :comment INNER JOIN guests
end ON guests.comment_id = comments.id
class Tag < ActiveRecord::Base
belongs_to :post “return all posts that have a comment made by a guest”
end
ROR Lab.

47. Joining Tables
- Using Array/Hash of Named Associations -
only with INNER JOIN
class Category < ActiveRecord::Base
has_many :posts
end
class Post < ActiveRecord::Base • Nested Associations(Multiple Level)
belongs_to :category
has_many :comments
has_many :tags
end Category.joins(:posts =>
class Comment < ActiveRecord::Base
[{:comments => :guest}, :tags]
belongs_to :post
has_one :guest
end
SELECT categories.* FROM categories
class Guest < ActiveRecord::Base INNER JOIN posts ON posts.category_id = categories.id
belongs_to :comment
INNER JOIN comments ON comments.post_id = posts.id
end
INNER JOIN guests ON guests.id = comments.quest_id
class Tag < ActiveRecord::Base INNER JOIN tags ON tags.post_id = posts.id
belongs_to :post
end
ROR Lab.

48. Joining Tables
- Specifying Conditions on the Joined Tables -
: using Array and String Conditions
time_range = (Time.now.midnight - 1.day)..Time.now.midnight
Client.joins(:orders)
.where('orders.created_at' => time_range)
: using nested Hash Conditions
time_range = (Time.now.midnight - 1.day)..Time.now.midnight
Client.joins(:orders)
.where(:orders => {:created_at => time_range})
ROR Lab.

49. Joining Tables
- Inner Join -
SELECT <select_list>
FROM TableA A
INNER JOIN TableB B
ON A.Key = B.Key
ROR Lab.

50. Joining Tables
- Left Join -
SELECT <select_list> SELECT <select_list>
FROM TableA A FROM TableA A
LEFT JOIN TableB B LEFT JOIN TableB B
ON A.Key = B.Key ON A.Key = B.Key
WHERE B.Key IS NULL
ROR Lab.

51. Joining Tables
- Right Join -
SELECT <select_list> SELECT <select_list>
FROM TableA A FROM TableA A
RIGHT JOIN TableB B RIGHT JOIN TableB B
ON A.Key = B.Key ON A.Key = B.Key
WHERE A.Key IS NULL
ROR Lab.

52. Joining Tables
- Full Outer Join -
SELECT <select_list> SELECT <select_list>
FROM TableA A FROM TableA A
FULL OUTER JOIN TableB B FULL OUTER JOIN TableB B
ON A.Key = B.Key ON A.Key = B.Key
WHERE A.Key IS NULL
OR B.Key IS NULL
ROR Lab.

53. ROR Lab.

54. 감사합니다.

55.
ROR Lab.