1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
|
h2. Active Record Query Interface
This guide covers different ways to retrieve data from the database using Active Record. By referring to this guide, you will be able to:
* Find records using a variety of methods and conditions
* Specify the order, retrieved attributes, grouping, and other properties of the found records
* Use eager loading to reduce the number of database queries needed for data retrieval
* Use dynamic finders methods
* Create named scopes to add custom finding behavior to your models
* Check for the existence of particular records
* Perform various calculations on Active Record models
endprologue.
If you're used to using raw SQL to find database records then, generally, you will find that there are better ways to carry out the same operations in Rails. Active Record insulates you from the need to use SQL in most cases.
Code examples throughout this guide will refer to one or more of the following models:
TIP: All of the following models uses +id+ as the primary key, unless specified otherwise.
<br />
<ruby>
class Client < ActiveRecord::Base
has_one :address
has_one :mailing_address
has_many :orders
has_and_belongs_to_many :roles
end
</ruby>
<ruby>
class Address < ActiveRecord::Base
belongs_to :client
end
</ruby>
<ruby>
class MailingAddress < Address
end
</ruby>
<ruby>
class Order < ActiveRecord::Base
belongs_to :client, :counter_cache => true
end
</ruby>
<ruby>
class Role < ActiveRecord::Base
has_and_belongs_to_many :clients
end
</ruby>
Active Record will perform queries on the database for you and is compatible with most database systems (MySQL, PostgreSQL and SQLite to name a few). Regardless of which database system you're using, the Active Record method format will always be the same.
h3. Retrieving objects from the database
To retrieve objects from the database, Active Record provides a class method called +Model.find+. This method allows you to pass arguments into it to perform certain queries on your database without the need of writing raw SQL.
Primary operation of <tt>Model.find(options)</tt> can be summarized as:
* Convert the supplied options to an equivalent SQL query.
* Fire the SQL query and retrieve the corresponding results from the database.
* Instantiate the equivalent Ruby object of the appropriate model for every resulting row.
* Run +after_find+ callbacks if any.
h4. Retrieving a Single Object
Active Record lets you retrieve a single object using three different ways.
h5. Using a primary key
Using <tt>Model.find(primary_key)</tt>, you can retrieve the object corresponding to the supplied _primary key_. For example:
<ruby>
# Find the client with primary key (id) 10.
client = Client.find(10)
=> #<Client id: 10, name: => "Ryan">
</ruby>
SQL equivalent of the above is:
<sql>
SELECT * FROM clients WHERE (clients.id = 10)
</sql>
<tt>Model.find(primary_key)</tt> will raise an +ActiveRecord::RecordNotFound+ exception if no matching record is found.
h5. Find First
<tt>Model.first(options = nil)</tt> finds the first record matched by the supplied options. If no +options+ are supplied, the first matching record is returned. For example:
<ruby>
# Find the client with primary key (id) 10.
client = Client.first
=> #<Client id: 1, name: => "Lifo">
</ruby>
SQL equivalent of the above is:
<sql>
SELECT * FROM clients LIMIT 1
</sql>
<tt>Model.first</tt> returns +nil+ if no matching record is found. No exception will be raised.
NOTE: +Model.find(:first, options)+ is equivalent to +Model.first(options)+
h5. Find Last
<tt>Model.last(options = nil)</tt> finds the last record matched by the supplied options. If no +options+ are supplied, the last matching record is returned. For example:
<ruby>
# Find the client with primary key (id) 10.
client = Client.last
=> #<Client id: 221, name: => "Russel">
</ruby>
SQL equivalent of the above is:
<sql>
SELECT * FROM clients ORDER BY clients.id DESC LIMIT 1
</sql>
<tt>Model.last</tt> returns +nil+ if no matching record is found. No exception will be raised.
NOTE: +Model.find(:last, options)+ is equivalent to +Model.last(options)+
h4. Retrieving Multiple Objects
h5. Using multiple primary keys
<tt>Model.find(array_of_primary_key)</tt> also accepts an array of _primary keys_. An array of all the matching records for the supplied _primary keys_ is returned. For example:
<ruby>
# Find the clients with primary keys 1 and 10.
client = Client.find(1, 10) # Or even Client.find([1, 10])
=> [#<Client id: 1, name: => "Lifo">, #<Client id: 10, name: => "Ryan">]
</ruby>
SQL equivalent of the above is:
<sql>
SELECT * FROM clients WHERE (clients.id IN (1,10))
</sql>
<tt>Model.find(array_of_primary_key)</tt> will raise an +ActiveRecord::RecordNotFound+ exception unless a matching record is found for <strong>all</strong> of the supplied primary keys.
h5. Find All
<tt>Model.all(options = nil)</tt> finds all the records matching the supplied +options+. If no +options+ are supplied, all rows from the database are returned.
<ruby>
# Find all the clients.
client = Client.all
=> [#<Client id: 1, name: => "Lifo">, #<Client id: 10, name: => "Ryan">, #<Client id: 221, name: => "Russel">]
</ruby>
And the equivalent SQL is:
<sql>
SELECT * FROM clients
</sql>
<tt>Model.all</tt> returns an empty array +[]+ if no matching record is found. No exception will be raised.
h3. Conditions
The +find+ method allows you to specify conditions to limit the records returned. You can specify conditions as a string, array, or hash.
h4. Pure String Conditions
If you'd like to add conditions to your find, you could just specify them in there, just like +Client.first(:conditions => "orders_count = '2'")+. This will find all clients where the +orders_count+ field's value is 2.
WARNING: Building your own conditions as pure strings can leave you vulnerable to SQL injection exploits. For example, +Client.first(:conditions => "name LIKE '%#{params[:name]}%'")+ is not safe. See the next section for the preferred way to handle conditions using an array.
h4. Array Conditions
Now what if that number could vary, say as a argument from somewhere, or perhaps from the user's level status somewhere? The find then becomes something like +Client.first(:conditions => ["orders_count = ?", params[:orders]])+. Active Record will go through the first element in the conditions value and any additional elements will replace the question marks (?) in the first element. If you want to specify two conditions, you can do it like +Client.first(:conditions => ["orders_count = ? AND locked = ?", params[:orders], false])+. In this example, the first question mark will be replaced with the value in +params[:orders]+ and the second will be replaced with the SQL representation of +false+, which depends on the adapter.
The reason for doing code like:
<ruby>
Client.first(:conditions => ["orders_count = ?", params[:orders]])
</ruby>
instead of:
<ruby>
Client.first(:conditions => "orders_count = #{params[:orders]}")
</ruby>
is because of argument safety. Putting the variable directly into the conditions string will pass the variable to the database *as-is*. This means that it will be an unescaped variable directly from a user who may have malicious intent. If you do this, you put your entire database at risk because once a user finds out he or she can exploit your database they can do just about anything to it. Never ever put your arguments directly inside the conditions string.
TIP: For more information on the dangers of SQL injection, see the "Ruby on Rails Security Guide":../security.html#_sql_injection.
If you're looking for a range inside of a table (for example, users created in a certain timeframe) you can use the conditions option coupled with the IN sql statement for this. If you had two dates coming in from a controller you could do something like this to look for a range:
<ruby>
Client.all(:conditions => ["created_at IN (?)",
(params[:start_date].to_date)..(params[:end_date].to_date)])
</ruby>
This would generate the proper query which is great for small ranges but not so good for larger ranges. For example if you pass in a range of date objects spanning a year that's 365 (or possibly 366, depending on the year) strings it will attempt to match your field against.
<sql>
SELECT * FROM users WHERE (created_at IN
('2007-12-31','2008-01-01','2008-01-02','2008-01-03','2008-01-04','2008-01-05',
'2008-01-06','2008-01-07','2008-01-08','2008-01-09','2008-01-10','2008-01-11',
'2008-01-12','2008-01-13','2008-01-14','2008-01-15','2008-01-16','2008-01-17',
'2008-01-18','2008-01-19','2008-01-20','2008-01-21','2008-01-22','2008-01-23',...
‘2008-12-15','2008-12-16','2008-12-17','2008-12-18','2008-12-19','2008-12-20',
'2008-12-21','2008-12-22','2008-12-23','2008-12-24','2008-12-25','2008-12-26',
'2008-12-27','2008-12-28','2008-12-29','2008-12-30','2008-12-31'))
</sql>
Things can get *really* messy if you pass in Time objects as it will attempt to compare your field to *every second* in that range:
<ruby>
Client.all(:conditions => ["created_at IN (?)",
(params[:start_date].to_date.to_time)..(params[:end_date].to_date.to_time)])
</ruby>
<sql>
SELECT * FROM users WHERE (created_at IN
('2007-12-01 00:00:00', '2007-12-01 00:00:01' ...
'2007-12-01 23:59:59', '2007-12-02 00:00:00'))
</sql>
This could possibly cause your database server to raise an unexpected error, for example MySQL will throw back this error:
<shell>
Got a packet bigger than 'max_allowed_packet' bytes: _query_
</shell>
Where _query_ is the actual query used to get that error.
In this example it would be better to use greater-than and less-than operators in SQL, like so:
<ruby>
Client.all(:conditions =>
["created_at > ? AND created_at < ?", params[:start_date], params[:end_date]])
</ruby>
You can also use the greater-than-or-equal-to and less-than-or-equal-to like this:
<ruby>
Client.all(:conditions =>
["created_at >= ? AND created_at <= ?", params[:start_date], params[:end_date]])
</ruby>
Just like in Ruby. If you want a shorter syntax be sure to check out the "Hash Conditions":hash-conditions section later on in the guide.
h4. Placeholder Conditions
Similar to the array style of params you can also specify keys in your conditions:
<ruby>
Client.all(:conditions =>
["created_at >= :start_date AND created_at <= :end_date", { :start_date => params[:start_date], :end_date => params[:end_date] }])
</ruby>
This makes for clearer readability if you have a large number of variable conditions.
h4. Hash Conditions
Rails also allows you to pass in a hash conditions which can increase the readability of your conditions syntax. With hash conditions, you pass in a hash with keys of the fields you want conditionalised and the values of how you want to conditionalise them:
<ruby>
Client.all(:conditions => { :locked => true })
</ruby>
The field name does not have to be a symbol it can also be a string:
<ruby>
Client.all(:conditions => { 'locked' => true })
</ruby>
The good thing about this is that we can pass in a range for our fields without it generating a large query as shown in the preamble of this section.
<ruby>
Client.all(:conditions => { :created_at => (Time.now.midnight - 1.day)..Time.now.midnight})
</ruby>
This will find all clients created yesterday by using a BETWEEN sql statement:
<sql>
SELECT * FROM clients WHERE (clients.created_at BETWEEN '2008-12-21 00:00:00' AND '2008-12-22 00:00:00')
</sql>
This demonstrates a shorter syntax for the examples in "Array Conditions":#array-conditions
You can also join in tables and specify their columns in the hash:
<ruby>
Client.all(:include => "orders", :conditions => { 'orders.created_at' => (Time.now.midnight - 1.day)..Time.now.midnight })
</ruby>
An alternative and cleaner syntax to this is:
<ruby>
Client.all(:include => "orders", :conditions => { :orders => { :created_at => (Time.now.midnight - 1.day)..Time.now.midnight } })
</ruby>
This will find all clients who have orders that were created yesterday, again using a BETWEEN expression.
If you want to find records using the IN expression you can pass an array to the conditions hash:
<ruby>
Client.all(:include => "orders", :conditions => { :orders_count => [1,3,5] }
</ruby>
This code will generate SQL like this:
<sql>
SELECT * FROM clients WHERE (clients.orders_count IN (1,2,3))
</sql>
h3. Ordering
If you're getting a set of records and want to order them in ascending order by the +created_at+ field in your table, you can use +Client.all(:order => "created_at")+. If you'd like to order it in descending order, just tell it to do that using +Client.all(:order => "created_at desc")+. The value for this option is passed in as sanitized SQL and allows you to sort via multiple fields: +Client.all(:order => "created_at desc, orders_count asc")+.
h3. Selecting Certain Fields
To select certain fields, you can use the select option like this: +Client.first(:select => "viewable_by, locked")+. This select option does not use an array of fields, but rather requires you to type SQL-like code. The above code will execute +SELECT viewable_by, locked FROM clients LIMIT 1+ on your database.
Be careful because this also means you're initializing a model object with only the fields that you've selected. If you attempt to access a field that is not in the initialized record you'll receive:
<shell>
ActiveRecord::MissingAttributeError: missing attribute: <attribute>
</shell>
Where <attribute> is the attribute you asked for. The +id+ method will not raise the +ActiveRecord::MissingAttributeError+, so just be careful when working with associations because they need the +id+ method to function properly.
You can also call SQL functions within the select option. For example, if you would like to only grab a single record per unique value in a certain field by using the +DISTINCT+ function you can do it like this: +Client.all(:select => "DISTINCT(name)")+.
h3. Limit & Offset
If you want to limit the amount of records to a certain subset of all the records retrieved you usually use limit for this, sometimes coupled with offset. Limit is the maximum number of records that will be retrieved from a query, and offset is the number of records it will start reading from from the first record of the set. Take this code for example:
<ruby>
Client.all(:limit => 5)
</ruby>
This code will return a maximum of 5 clients and because it specifies no offset it will return the first 5 clients in the table. The SQL it executes will look like this:
<sql>
SELECT * FROM clients LIMIT 5
</sql>
<ruby>
Client.all(:limit => 5, :offset => 5)
</ruby>
This code will return a maximum of 5 clients and because it specifies an offset this time, it will return these records starting from the 5th client in the clients table. The SQL looks like:
<sql>
SELECT * FROM clients LIMIT 5, 5
</sql>
h3. Group
The group option for find is useful, for example, if you want to find a collection of the dates orders were created on. You could use the option in this context:
<ruby>
Order.all(:group => "date(created_at)", :order => "created_at")
</ruby>
And this will give you a single +Order+ object for each date where there are orders in the database.
The SQL that would be executed would be something like this:
<sql>
SELECT * FROM orders GROUP BY date(created_at)
</sql>
h3. Having
The +:having+ option allows you to specify SQL and acts as a kind of a filter on the group option. +:having+ can only be specified when +:group+ is specified.
An example of using it would be:
<ruby>
Order.all(:group => "date(created_at)", :having => ["created_at > ?", 1.month.ago])
</ruby>
This will return single order objects for each day, but only for the last month.
h3. Read Only
+readonly+ is a +find+ option that you can set in order to make that instance of the record read-only. Any attempt to alter or destroy the record will not succeed, raising an ActiveRecord::ReadOnlyRecord exception. To set this option, specify it like this:
<ruby>
Client.first(:readonly => true)
</ruby>
If you assign this record to a variable client, calling the following code will raise an ActiveRecord::ReadOnlyRecord exception:
<ruby>
client = Client.first(:readonly => true)
client.locked = false
client.save
</ruby>
h3. Lock
If you're wanting to stop race conditions for a specific record (for example, you're incrementing a single field for a record, potentially from multiple simultaneous connections) you can use the lock option to ensure that the record is updated correctly. For safety, you should use this inside a transaction.
<ruby>
Topic.transaction do
t = Topic.find(params[:id], :lock => true)
t.increment!(:views)
end
</ruby>
You can also pass SQL to this option to allow different types of locks. For example, MySQL has an expression called LOCK IN SHARE MODE where you can lock a record but still allow other queries to read it. To specify this expression just pass it in as the lock option:
<ruby>
Topic.transaction do
t = Topic.find(params[:id], :lock => "LOCK IN SHARE MODE")
t.increment!(:views)
end
</ruby>
h3. Making It All Work Together
You can chain these options together in no particular order as Active Record will write the correct SQL for you. If you specify two instances of the same options inside the +find+ method Active Record will use the last one you specified. This is because the options passed to find are a hash and defining the same key twice in a hash will result in the last definition being used.
h3. Eager Loading
Eager loading is loading associated records along with any number of records in as few queries as possible. For example, if you wanted to load all the addresses associated with all the clients in a single query you could use +Client.all(:include => :address)+. If you wanted to include both the address and mailing address for the client you would use +Client.find(:all, :include => [:address, :mailing_address])+. Include will first find the client records and then load the associated address records. Running script/server in one window, and executing the code through script/console in another window, the output should look similar to this:
<sql>
Client Load (0.000383) SELECT * FROM clients
Address Load (0.119770) SELECT addresses.* FROM addresses
WHERE (addresses.client_id IN (13,14))
MailingAddress Load (0.001985) SELECT mailing_addresses.* FROM
mailing_addresses WHERE (mailing_addresses.client_id IN (13,14))
</sql>
The numbers +13+ and +14+ in the above SQL are the ids of the clients gathered from the +Client.all+ query. Rails will then run a query to gather all the addresses and mailing addresses that have a client_id of 13 or 14. Although this is done in 3 queries, this is more efficient than not eager loading because without eager loading it would run a query for every time you called +address+ or +mailing_address+ on one of the objects in the clients array, which may lead to performance issues if you're loading a large number of records at once and is often called the "N+1 query problem". The problem is that the more queries your server has to execute, the slower it will run.
If you wanted to get all the addresses for a client in the same query you would do +Client.all(:joins => :address)+.
If you wanted to find the address and mailing address for that client you would do +Client.all(:joins => [:address, :mailing_address])+. This is more efficient because it does all the SQL in one query, as shown by this example:
<sql>
+Client Load (0.000455) SELECT clients.* FROM clients INNER JOIN addresses
ON addresses.client_id = client.id INNER JOIN mailing_addresses ON
mailing_addresses.client_id = client.id
</sql>
This query is more efficient, but there's a gotcha: if you have a client who does not have an address or a mailing address they will not be returned in this query at all. If you have any association as an optional association, you may want to use include rather than joins. Alternatively, you can use a SQL join clause to specify exactly the join you need (Rails always assumes an inner join):
<ruby>
Client.all(:joins => “LEFT OUTER JOIN addresses ON
client.id = addresses.client_id LEFT OUTER JOIN mailing_addresses ON
client.id = mailing_addresses.client_id”)
</ruby>
When using eager loading you can specify conditions for the columns of the tables inside the eager loading to get back a smaller subset. If, for example, you want to find a client and all their orders within the last two weeks you could use eager loading with conditions for this:
<ruby>
Client.first(:include => "orders", :conditions =>
["orders.created_at >= ? AND orders.created_at <= ?", 2.weeks.ago, Time.now])
</ruby>
h3. Dynamic finders
For every field (also known as an attribute) you define in your table, Active Record provides a finder method. If you have a field called +name+ on your Client model for example, you get +find_by_name+ and +find_all_by_name+ for free from Active Record. If you have also have a +locked+ field on the Client model, you also get +find_by_locked+ and +find_all_by_locked+.
You can do +find_last_by_*+ methods too which will find the last record matching your argument.
You can specify an exclamation point (!) on the end of the dynamic finders to get them to raise an ActiveRecord::RecordNotFound error if they do not return any records, like +Client.find_by_name!("Ryan")+
If you want to find both by name and locked, you can chain these finders together by simply typing +and+ between the fields for example +Client.find_by_name_and_locked("Ryan", true)+.
There's another set of dynamic finders that let you find or create/initialize objects if they aren't found. These work in a similar fashion to the other finders and can be used like +find_or_create_by_name(params[:name])+. Using this will firstly perform a find and then create if the find returns nil. The SQL looks like this for +Client.find_or_create_by_name("Ryan")+:
<sql>
SELECT * FROM clients WHERE (clients.name = 'Ryan') LIMIT 1
BEGIN
INSERT INTO clients (name, updated_at, created_at, orders_count, locked)
VALUES('Ryan', '2008-09-28 15:39:12', '2008-09-28 15:39:12', 0, '0')
COMMIT
</sql>
+find_or_create+'s sibling, +find_or_initialize+, will find an object and if it does not exist will act similar to calling +new+ with the arguments you passed in. For example:
<ruby>
client = Client.find_or_initialize_by_name('Ryan')
</ruby>
will either assign an existing client object with the name 'Ryan' to the client local variable, or initialize a new object similar to calling +Client.new(:name => 'Ryan')+. From here, you can modify other fields in client by calling the attribute setters on it: +client.locked = true+ and when you want to write it to the database just call +save+ on it.
h3. Finding By SQL
If you'd like to use your own SQL to find records in a table you can use +find_by_sql+. The +find_by_sql+ method will return an array of objects even the underlying query returns just a single record. For example you could run this query:
<ruby>
Client.find_by_sql("SELECT * FROM clients INNER JOIN orders ON clients.id = orders.client_id ORDER clients.created_at desc")
</ruby>
+find_by_sql+ provides you with a simple way of making custom calls to the database and retrieving instantiated objects.
h3. select_all
+find_by_sql+ has a close relative called +connection#select_all+. +select_all+ will retrieve objects from the database using custom SQL just like +find_by_sql+ but will not instantiate them. Instead, you will get an array of hashes where each hash indicates a record.
<ruby>
Client.connection.select_all("SELECT * FROM clients WHERE id = '1'")
</ruby>
h3. Working with Associations
When you define a has_many association on a model you get the +find+ method and dynamic finders also on that association. This is helpful for finding associated records within the scope of an existing record, for example finding all the orders for a client that have been sent and not received by doing something like +Client.find(params[:id]).orders.find_by_sent_and_received(true, false)+. Having this find method available on associations is extremely helpful when using nested resources.
h3. Named Scopes
Named scopes are another way to add custom finding behavior to the models in the application. Named scopes provide an object-oriented way to narrow the results of a query.
h4. Simple Named Scopes
Suppose we want to find all clients who are male. You could use this code:
<ruby>
class Client < ActiveRecord::Base
named_scope :males, :conditions => { :gender => "male" }
end
</ruby>
Then you could call +Client.males.all+ to get all the clients who are male. Please note that if you do not specify the +all+ on the end you will get a +Scope+ object back, not a set of records which you do get back if you put the +all+ on the end.
If you wanted to find all the clients who are active, you could use this:
<ruby>
class Client < ActiveRecord::Base
named_scope :active, :conditions => { :active => true }
end
</ruby>
You can call this new named_scope with +Client.active.all+ and this will do the same query as if we just used +Client.all(:conditions => ["active = ?", true])+. If you want to find the first client within this named scope you could do +Client.active.first+.
h4. Combining Named Scopes
If you wanted to find all the clients who are active and male you can stack the named scopes like this:
<ruby>
Client.males.active.all
</ruby>
If you would then like to do a +all+ on that scope, you can. Just like an association, named scopes allow you to call +all+ on them:
<ruby>
Client.males.active.all(:conditions => ["age > ?", params[:age]])
</ruby>
h4. Runtime Evaluation of Named Scope Conditions
Consider the following code:
<ruby>
class Client < ActiveRecord::Base
named_scope :recent, :conditions => { :created_at > 2.weeks.ago }
end
</ruby>
This looks like a standard named scope that defines a method called +recent+ which gathers all records created any time between now and 2 weeks ago. That's correct for the first time the model is loaded but for any time after that, +2.weeks.ago+ is set to that same value, so you will consistently get records from a certain date until your model is reloaded by something like your application restarting. The way to fix this is to put the code in a lambda block:
<ruby>
class Client < ActiveRecord::Base
named_scope :recent, lambda { { :conditions => ["created_at > ?", 2.weeks.ago] } }
end
</ruby>
And now every time the +recent+ named scope is called, the code in the lambda block will be executed, so you'll get actually 2 weeks ago from the code execution, not 2 weeks ago from the time the model was loaded.
h4. Named Scopes with Multiple Models
In a named scope you can use +:include+ and +:joins+ options just like in +find+.
<ruby>
class Client < ActiveRecord::Base
named_scope :active_within_2_weeks
lambda { { :joins => :order, :conditions => ["orders.created_at > ?", 2.weeks.ago] } }
end
</ruby>
This method, called as +Client.active_within_2_weeks.all+, will return all clients who have placed orders in the past 2 weeks.
h4. Arguments to Named Scopes
If you want to pass to a named scope a required argument, just specify it as a block argument like this:
<ruby>
class Client < ActiveRecord::Base
named_scope :recent, lambda { |time| { :conditions => ["created_at > ?", time] } }
end
</ruby>
This will work if you call +Client.recent(2.weeks.ago).all+ but not if you call +Client.recent+. If you want to add an optional argument for this, you have to use prefix the arugment with an *.
<ruby>
class Client < ActiveRecord::Base
named_scope :recent, lambda { |*args| { :conditions => ["created_at > ?", args.first || 2.weeks.ago] } }
end
</ruby>
This will work with +Client.recent(2.weeks.ago).all+ and +Client.recent.all+, with the latter always returning records with a created_at date between right now and 2 weeks ago.
Remember that named scopes are stackable, so you will be able to do +Client.recent(2.weeks.ago).unlocked.all+ to find all clients created between right now and 2 weeks ago and have their locked field set to false.
h4. Anonymous Scopes
All Active Record models come with a named scope named +scoped+, which allows you to create anonymous scopes. For example:
<ruby>
class Client < ActiveRecord::Base
def self.recent
scoped :conditions => ["created_at > ?", 2.weeks.ago]
end
end
</ruby>
Anonymous scopes are most useful to create scopes "on the fly":
<ruby>
Client.scoped(:conditions => { :gender => "male" })
</ruby>
Just like named scopes, anonymous scopes can be stacked, either with other anonymous scopes or with regular named scopes.
h3. Existence of Objects
If you simply want to check for the existence of the object there's a method called +exists?+. This method will query the database using the same query as +find+, but instead of returning an object or collection of objects it will return either +true+ or false+.
<ruby>
Client.exists?(1)
</ruby>
The +exists?+ method also takes multiple ids, but the catch is that it will return true if any one of those records exists.
<ruby>
Client.exists?(1,2,3)
# or
Client.exists?([1,2,3])
</ruby>
Further more, +exists+ takes a +conditions+ option much like find:
<ruby>
Client.exists?(:conditions => "first_name = 'Ryan'")
</ruby>
h3. Calculations
This section uses count as an example method in this preamble, but the options described apply to all sub-sections.
+count+ takes conditions much in the same way +exists?+ does:
<ruby>
Client.count(:conditions => "first_name = 'Ryan'")
</ruby>
Which will execute:
<sql>
SELECT count(*) AS count_all FROM clients WHERE (first_name = 'Ryan')
</sql>
You can also use +:include+ or +:joins+ for this to do something a little more complex:
<ruby>
Client.count(:conditions => "clients.first_name = 'Ryan' AND orders.status = 'received'", :include => "orders")
</ruby>
Which will execute:
<sql>
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')
</sql>
This code specifies +clients.first_name+ just in case one of the join tables has a field also called +first_name+ and it uses +orders.status+ because that's the name of our join table.
h4. Count
If you want to see how many records are in your model's table you could call +Client.count+ and that will return the number. If you want to be more specific and find all the clients with their age present in the database you can use +Client.count(:age)+.
For options, please see the parent section, "Calculations":#calculations.
h4. Average
If you want to see the average of a certain number in one of your tables you can call the +average+ method on the class that relates to the table. This method call will look something like this:
<ruby>
Client.average("orders_count")
</ruby>
This will return a number (possibly a floating point number such as 3.14159265) representing the average value in the field.
For options, please see the parent section, "Calculations":#calculations.
h4. Minimum
If you want to find the minimum value of a field in your table you can call the +minimum+ method on the class that relates to the table. This method call will look something like this:
<ruby>
Client.minimum("age")
</ruby>
For options, please see the parent section, "Calculations":#calculations.
h4. Maximum
If you want to find the maximum value of a field in your table you can call the +maximum+ method on the class that relates to the table. This method call will look something like this:
<ruby>
Client.maximum("age")
</ruby>
For options, please see the parent section, "Calculations":#calculations.
h4. Sum
If you want to find the sum of a field for all records in your table you can call the +sum+ method on the class that relates to the table. This method call will look something like this:
<ruby>
Client.sum("orders_count")
</ruby>
For options, please see the parent section, "Calculations":#calculations.
h3. Changelog
"Lighthouse ticket":http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/16
* December 29 2008: Initial version by Ryan Bigg
|