From 3bf2ee57b01084b8cbe6222c1eacb4cd2b37cd6c Mon Sep 17 00:00:00 2001 From: Pratik Naik Date: Mon, 12 Jan 2009 18:49:41 +0000 Subject: [PATCH] Update internal middlewares/purpose table. --- .../guides/html/active_record_querying.html | 1630 ++++++++--------- railties/doc/guides/html/authors.html | 10 +- railties/doc/guides/html/index.html | 6 +- .../doc/guides/html/performance_testing.html | 4 +- railties/doc/guides/html/rails_on_rack.html | 42 +- railties/doc/guides/source/rails_on_rack.txt | 35 +- 6 files changed, 886 insertions(+), 841 deletions(-) diff --git a/railties/doc/guides/html/active_record_querying.html b/railties/doc/guides/html/active_record_querying.html index d2300bf66dc..043e5120d13 100644 --- a/railties/doc/guides/html/active_record_querying.html +++ b/railties/doc/guides/html/active_record_querying.html @@ -183,7 +183,7 @@ - +

Ruby on Rails

Sustainable productivity for web-application development

@@ -194,7 +194,7 @@

Sustainable productivity for web-application develop
- + - +

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 -

    -
    • -
-

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 in this guide use one or more of the following models:

-
-
-
class Client < ActiveRecord::Base
-  has_one :address
-  has_one :mailing_address
-  has_many :orders
-  has_and_belongs_to_many :roles
-end
-
-
-
class Address < ActiveRecord::Base
-  belongs_to :client
-end
-
-
-
class MailingAddress < Address
-end
-
-
-
class Order < ActiveRecord::Base
-  belongs_to :client, :counter_cache => true
-end
-
-
-
class Role < ActiveRecord::Base
-  has_and_belongs_to_many :clients
-end
-
-
-

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.

-
-
-
-

1. IDs, First, Last and All

-
-

ActiveRecord::Base has methods defined on it to make interacting with your database and the tables within it much, much easier. For finding records, the key method is find. This method allows you to pass arguments into it to perform certain queries on your database without the need of SQL. If you wanted to find the record with the id of 1, you could type Client.find(1) which would execute this query on your database:

-
-
-
SELECT * FROM clients WHERE (clients.id = 1)
-
- - - -
-Note -Because this is a standard table created from a migration in Rails, the primary key is defaulted to id. If you have specified a different primary key in your migrations, this is what Rails will find on when you call the find method, not the id column.
-
-

If you wanted to find clients with id 1 or 2, you call Client.find([1,2]) or Client.find(1,2) and then this will be executed as:

-
-
-
SELECT * FROM clients WHERE (clients.id IN (1,2))
-
-
-
>> Client.find(1,2)
-=> [#<Client id: 1, name: => "Ryan", locked: false, orders_count: 2,
-  created_at: "2008-09-28 15:38:50", updated_at: "2008-09-28 15:38:50">,
-  #<Client id: 2, name: => "Michael", locked: false, orders_count: 3,
-  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40">]
-
-

Note that if you pass in a list of numbers that the result will be returned as an array, not as a single Client object.

-
- - - -
-Note -If find(id) or find([id1, id2]) fails to find any records, it will raise a RecordNotFound exception.
-
-

If you wanted to find the first Client object you would simply type Client.first and that would find the first client in your clients table:

-
-
-
>> Client.first
-=> #<Client id: 1, name: => "Ryan", locked: false, orders_count: 2,
-  created_at: "2008-09-28 15:38:50", updated_at: "2008-09-28 15:38:50">
-
-

If you were reading your log file (the default is log/development.log) you may see something like this:

-
-
-
SELECT * FROM clients LIMIT 1
-

Indicating the query that Rails has performed on your database.

-

To find the last Client object you would simply type Client.last and that would find the last client created in your clients table:

-
-
-
>> Client.last
-=> #<Client id: 2, name: => "Michael", locked: false, orders_count: 3,
-  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40">
-
-

If you were reading your log file (the default is log/development.log) you may see something like this:

-
-
-
SELECT * FROM clients ORDER BY id DESC LIMIT 1
-
- - - -
-Note -Please be aware that the syntax that Rails uses to find the first record in the table means that it may not be the actual first record. If you want the actual first record based on a field in your table (e.g. created_at) specify an order option in your find call. The last method call works differently: it finds the last record on your table based on the primary key column.
-
-
-
-
SELECT * FROM clients ORDER BY clients.id DESC LIMIT 1
-

To find all the Client objects you would simply type Client.all and that would find all the clients in your clients table:

-
-
-
>> Client.all
-=> [#<Client id: 1, name: => "Ryan", locked: false, orders_count: 2,
-  created_at: "2008-09-28 15:38:50", updated_at: "2008-09-28 15:38:50">,
-  #<Client id: 2, name: => "Michael", locked: false, orders_count: 3,
-  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40">]
-
-

You may see in Rails code that there are calls to methods such as Client.find(:all), Client.find(:first) and Client.find(:last). These methods are just alternatives to Client.all, Client.first and Client.last respectively.

-

Be aware that Client.first/Client.find(:first) and Client.last/Client.find(:last) will both return a single object, where as Client.all/Client.find(:all) will return an array of Client objects, just as passing in an array of ids to find will do also.

-
-

2. Conditions

-
-

The find method allows you to specify conditions to limit the records returned. You can specify conditions as a string, array, or hash.

-

2.1. 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.
-
-

2.2. 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:

-
-
-
Client.first(:conditions => ["orders_count = ?", params[:orders]])
-

instead of:

-
-
-
Client.first(:conditions => "orders_count = #{params[:orders]}")
-

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.
-
-

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:

-
-
-
Client.all(:conditions => ["created_at IN (?)",
-  (params[:start_date].to_date)..(params[:end_date].to_date)])
-

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.

-
-
-
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'))
-

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:

-
-
-
Client.all(:conditions => ["created_at IN (?)",
-  (params[:start_date].to_date.to_time)..(params[:end_date].to_date.to_time)])
-
-
-
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'))
-

This could possibly cause your database server to raise an unexpected error, for example MySQL will throw back this error:

-
-
-
Got a packet bigger than 'max_allowed_packet' bytes: _query_
-
-

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:

-
-
-
Client.all(:conditions =>
-  ["created_at > ? AND created_at < ?", params[:start_date], params[:end_date]])
-

You can also use the greater-than-or-equal-to and less-than-or-equal-to like this:

-
-
-
Client.all(:conditions =>
-  ["created_at >= ? AND created_at <= ?", params[:start_date], params[:end_date]])
-

Just like in Ruby. If you want a shorter syntax be sure to check out the Hash Conditions section later on in the guide.

-

2.3. Placeholder Conditions

-

Similar to the array style of params you can also specify keys in your conditions:

-
-
-
Client.all(:conditions =>
-  ["created_at >= :start_date AND created_at <= :end_date", { :start_date => params[:start_date], :end_date => params[:end_date] }])
-

This makes for clearer readability if you have a large number of variable conditions.

-

2.4. 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:

-
-
-
Client.all(:conditions => { :locked => true })
-

The field name does not have to be a symbol it can also be a string:

-
-
-
Client.all(:conditions => { 'locked' => true })
-

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.

-
-
-
Client.all(:conditions => { :created_at => (Time.now.midnight - 1.day)..Time.now.midnight})
-

This will find all clients created yesterday by using a BETWEEN sql statement:

-
-
-
SELECT * FROM `clients` WHERE (`clients`.`created_at` BETWEEN '2008-12-21 00:00:00' AND '2008-12-22 00:00:00')
-

This demonstrates a shorter syntax for the examples in Array Conditions

-

You can also join in tables and specify their columns in the hash:

-
-
-
Client.all(:include => "orders", :conditions => { 'orders.created_at' => (Time.now.midnight - 1.day)..Time.now.midnight })
-

An alternative and cleaner syntax to this is:

-
-
-
Client.all(:include => "orders", :conditions => { :orders => { :created_at => (Time.now.midnight - 1.day)..Time.now.midnight } })
-

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:

-
-
-
Client.all(:include => "orders", :conditions => { :orders_count => [1,3,5] }
-

This code will generate SQL like this:

-
-
-
SELECT * FROM `clients` WHERE (`clients`.`orders_count` IN (1,2,3))
-
-

3. 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").

-
-

4. 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:

-
-
-
ActiveRecord::MissingAttributeError: missing attribute: <attribute>
-
-

Where <attribute> is the atrribute 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)").

-
-

5. 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:

-
-
-
Client.all(:limit => 5)
-

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:

-
-
-
SELECT * FROM clients LIMIT 5
-
-
-
Client.all(:limit => 5, :offset => 5)
-

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:

-
-
-
SELECT * FROM clients LIMIT 5, 5
-
-

6. 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:

-
-
-
Order.all(:group => "date(created_at)", :order => "created_at")
-

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:

-
-
-
SELECT * FROM orders GROUP BY date(created_at)
-
-

7. 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:

-
-
-
Order.all(:group => "date(created_at)", :having => ["created_at > ?", 1.month.ago])
-

This will return single order objects for each day, but only for the last month.

-
-

8. 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:

-
-
-
Client.first(:readonly => true)
-

If you assign this record to a variable client, calling the following code will raise an ActiveRecord::ReadOnlyRecord exception:

-
-
-
client = Client.first(:readonly => true)
-client.locked = false
-client.save
-
-

9. 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.

-
-
-
Topic.transaction do
-  t = Topic.find(params[:id], :lock => true)
-  t.increment!(:views)
-end
-

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:

-
-
-
Topic.transaction do
-  t = Topic.find(params[:id], :lock => "LOCK IN SHARE MODE")
-  t.increment!(:views)
-end
-
-

10. 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.

-
-

11. 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:

-
-
-
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))
-

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:

-
-
-
+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
-

This query is more efficent, 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):

-
-
-
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”)
-

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:

-
-
-
Client.first(:include => "orders", :conditions =>
-  ["orders.created_at >= ? AND orders.created_at <= ?", 2.weeks.ago, Time.now])
-
-

12. 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"):

-
-
-
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
-

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:

-
-
-
client = Client.find_or_initialize_by_name('Ryan')
-

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.

-
-

13. 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:

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

find_by_sql provides you with a simple way of making custom calls to the database and retrieving instantiated objects.

-
-

14. 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.

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

15. 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.

-
-

16. 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.

-

16.1. Simple Named Scopes

-

Suppose we want to find all clients who are male. You could use this code:

-
-
-
class Client < ActiveRecord::Base
-  named_scope :males, :conditions => { :gender => "male" }
-end
-

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:

-
-
-
class Client < ActiveRecord::Base
-  named_scope :active, :conditions => { :active => true }
-end
-

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.

-

16.2. Combining Named Scopes

-

If you wanted to find all the clients who are active and male you can stack the named scopes like this:

-
-
-
Client.males.active.all
-

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:

-
-
-
Client.males.active.all(:conditions => ["age > ?", params[:age]])
-

16.3. Runtime Evaluation of Named Scope Conditions

-

Consider the following code:

-
-
-
class Client < ActiveRecord::Base
-  named_scope :recent, :conditions => { :created_at > 2.weeks.ago }
-end
-

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:

-
-
-
class Client < ActiveRecord::Base
-  named_scope :recent, lambda { { :conditions => ["created_at > ?", 2.weeks.ago] } }
-end
-

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.

-

16.4. Named Scopes with Multiple Models

-

In a named scope you can use :include and :joins options just like in find.

-
-
-
class Client < ActiveRecord::Base
-  named_scope :active_within_2_weeks, :joins => :order,
-    lambda { { :conditions => ["orders.created_at > ?", 2.weeks.ago] } }
-end
-

This method, called as Client.active_within_2_weeks.all, will return all clients who have placed orders in the past 2 weeks.

-

16.5. Arguments to Named Scopes

-

If you want to pass to a named scope a required arugment, just specify it as a block argument like this:

-
-
-
class Client < ActiveRecord::Base
-  named_scope :recent, lambda { |time| { :conditions => ["created_at > ?", time] } }
-end
-

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 *.

-
-
-
class Client < ActiveRecord::Base
-  named_scope :recent, lambda { |*args| { :conditions => ["created_at > ?", args.first || 2.weeks.ago] } }
-end
-

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.

-

16.6. Anonymous Scopes

-

All Active Record models come with a named scope named scoped, which allows you to create anonymous scopes. For example:

-
-
-
class Client < ActiveRecord::Base
-  def self.recent
-    scoped :conditions => ["created_at > ?", 2.weeks.ago]
-  end
-end
-

Anonymous scopes are most useful to create scopes "on the fly":

-
-
-
Client.scoped(:conditions => { :gender => "male" })
-

Just like named scopes, anonymous scopes can be stacked, either with other anonymous scopes or with regular named scopes.

-
-

17. 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+.

-
-
-
Client.exists?(1)
-

The exists? method also takes multiple ids, but the catch is that it will return true if any one of those records exists.

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

Further more, exists takes a conditions option much like find:

-
-
-
Client.exists?(:conditions => "first_name = 'Ryan'")
-
-

18. 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:

-
-
-
Client.count(:conditions => "first_name = 'Ryan'")
-

Which will execute:

-
-
-
SELECT count(*) AS count_all FROM clients WHERE (first_name = 'Ryan')
-

You can also use :include or :joins for this to do something a little more complex:

-
-
-
Client.count(:conditions => "clients.first_name = 'Ryan' AND orders.status = 'received'", :include => "orders")
-

Which will execute:

-
-
-
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')
-

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.

-

18.1. 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.

-

18.2. 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:

-
-
-
Client.average("orders_count")
-

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.

-

18.3. 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:

-
-
-
Client.minimum("age")
-

For options, please see the parent section, Calculations

-

18.4. 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:

-
-
-
Client.maximum("age")
-

For options, please see the parent section, Calculations

-

18.5. 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:

-
-
-
Client.sum("orders_count")
-

For options, please see the parent section, Calculations

-
-

19. Changelog

-
-

Lighthouse ticket

-
    -
  • -

    -December 29 2008: Initial version by Ryan Bigg -

    -
    • -
-
+
+
+

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 +

    +
    • +
+

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 in this guide use one or more of the following models:

+
+
+
class Client < ActiveRecord::Base
+  has_one :address
+  has_one :mailing_address
+  has_many :orders
+  has_and_belongs_to_many :roles
+end
+
+
+
class Address < ActiveRecord::Base
+  belongs_to :client
+end
+
+
+
class MailingAddress < Address
+end
+
+
+
class Order < ActiveRecord::Base
+  belongs_to :client, :counter_cache => true
+end
+
+
+
class Role < ActiveRecord::Base
+  has_and_belongs_to_many :clients
+end
+
+
+

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.

+
+
+
+

1. IDs, First, Last and All

+
+

ActiveRecord::Base has methods defined on it to make interacting with your database and the tables within it much, much easier. For finding records, the key method is find. This method allows you to pass arguments into it to perform certain queries on your database without the need of SQL. If you wanted to find the record with the id of 1, you could type Client.find(1) which would execute this query on your database:

+
+
+
SELECT * FROM clients WHERE (clients.id = 1)
+
+ + + +
+Note +Because this is a standard table created from a migration in Rails, the primary key is defaulted to id. If you have specified a different primary key in your migrations, this is what Rails will find on when you call the find method, not the id column.
+
+

If you wanted to find clients with id 1 or 2, you call Client.find([1,2]) or Client.find(1,2) and then this will be executed as:

+
+
+
SELECT * FROM clients WHERE (clients.id IN (1,2))
+
+
+
>> Client.find(1,2)
+=> [#<Client id: 1, name: => "Ryan", locked: false, orders_count: 2,
+  created_at: "2008-09-28 15:38:50", updated_at: "2008-09-28 15:38:50">,
+  #<Client id: 2, name: => "Michael", locked: false, orders_count: 3,
+  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40">]
+
+

Note that if you pass in a list of numbers that the result will be returned as an array, not as a single Client object.

+
+ + + +
+Note +If find(id) or find([id1, id2]) fails to find any records, it will raise a RecordNotFound exception.
+
+

If you wanted to find the first Client object you would simply type Client.first and that would find the first client in your clients table:

+
+
+
>> Client.first
+=> #<Client id: 1, name: => "Ryan", locked: false, orders_count: 2,
+  created_at: "2008-09-28 15:38:50", updated_at: "2008-09-28 15:38:50">
+
+

If you were reading your log file (the default is log/development.log) you may see something like this:

+
+
+
SELECT * FROM clients LIMIT 1
+

Indicating the query that Rails has performed on your database.

+

To find the last Client object you would simply type Client.last and that would find the last client created in your clients table:

+
+
+
>> Client.last
+=> #<Client id: 2, name: => "Michael", locked: false, orders_count: 3,
+  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40">
+
+

If you were reading your log file (the default is log/development.log) you may see something like this:

+
+
+
SELECT * FROM clients ORDER BY id DESC LIMIT 1
+
+ + + +
+Note +Please be aware that the syntax that Rails uses to find the first record in the table means that it may not be the actual first record. If you want the actual first record based on a field in your table (e.g. created_at) specify an order option in your find call. The last method call works differently: it finds the last record on your table based on the primary key column.
+
+
+
+
SELECT * FROM clients ORDER BY clients.id DESC LIMIT 1
+

To find all the Client objects you would simply type Client.all and that would find all the clients in your clients table:

+
+
+
>> Client.all
+=> [#<Client id: 1, name: => "Ryan", locked: false, orders_count: 2,
+  created_at: "2008-09-28 15:38:50", updated_at: "2008-09-28 15:38:50">,
+  #<Client id: 2, name: => "Michael", locked: false, orders_count: 3,
+  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40">]
+
+

You may see in Rails code that there are calls to methods such as Client.find(:all), Client.find(:first) and Client.find(:last). These methods are just alternatives to Client.all, Client.first and Client.last respectively.

+

Be aware that Client.first/Client.find(:first) and Client.last/Client.find(:last) will both return a single object, where as Client.all/Client.find(:all) will return an array of Client objects, just as passing in an array of ids to find will do also.

+
+

2. Conditions

+
+

The find method allows you to specify conditions to limit the records returned. You can specify conditions as a string, array, or hash.

+

2.1. 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.
+
+

2.2. 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:

+
+
+
Client.first(:conditions => ["orders_count = ?", params[:orders]])
+

instead of:

+
+
+
Client.first(:conditions => "orders_count = #{params[:orders]}")
+

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.
+
+

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:

+
+
+
Client.all(:conditions => ["created_at IN (?)",
+  (params[:start_date].to_date)..(params[:end_date].to_date)])
+

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.

+
+
+
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'))
+

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:

+
+
+
Client.all(:conditions => ["created_at IN (?)",
+  (params[:start_date].to_date.to_time)..(params[:end_date].to_date.to_time)])
+
+
+
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'))
+

This could possibly cause your database server to raise an unexpected error, for example MySQL will throw back this error:

+
+
+
Got a packet bigger than 'max_allowed_packet' bytes: _query_
+
+

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:

+
+
+
Client.all(:conditions =>
+  ["created_at > ? AND created_at < ?", params[:start_date], params[:end_date]])
+

You can also use the greater-than-or-equal-to and less-than-or-equal-to like this:

+
+
+
Client.all(:conditions =>
+  ["created_at >= ? AND created_at <= ?", params[:start_date], params[:end_date]])
+

Just like in Ruby. If you want a shorter syntax be sure to check out the Hash Conditions section later on in the guide.

+

2.3. Placeholder Conditions

+

Similar to the array style of params you can also specify keys in your conditions:

+
+
+
Client.all(:conditions =>
+  ["created_at >= :start_date AND created_at <= :end_date", { :start_date => params[:start_date], :end_date => params[:end_date] }])
+

This makes for clearer readability if you have a large number of variable conditions.

+

2.4. 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:

+
+
+
Client.all(:conditions => { :locked => true })
+

The field name does not have to be a symbol it can also be a string:

+
+
+
Client.all(:conditions => { 'locked' => true })
+

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.

+
+
+
Client.all(:conditions => { :created_at => (Time.now.midnight - 1.day)..Time.now.midnight})
+

This will find all clients created yesterday by using a BETWEEN sql statement:

+
+
+
SELECT * FROM `clients` WHERE (`clients`.`created_at` BETWEEN '2008-12-21 00:00:00' AND '2008-12-22 00:00:00')
+

This demonstrates a shorter syntax for the examples in Array Conditions

+

You can also join in tables and specify their columns in the hash:

+
+
+
Client.all(:include => "orders", :conditions => { 'orders.created_at' => (Time.now.midnight - 1.day)..Time.now.midnight })
+

An alternative and cleaner syntax to this is:

+
+
+
Client.all(:include => "orders", :conditions => { :orders => { :created_at => (Time.now.midnight - 1.day)..Time.now.midnight } })
+

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:

+
+
+
Client.all(:include => "orders", :conditions => { :orders_count => [1,3,5] }
+

This code will generate SQL like this:

+
+
+
SELECT * FROM `clients` WHERE (`clients`.`orders_count` IN (1,2,3))
+
+

3. 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").

+
+

4. 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:

+
+
+
ActiveRecord::MissingAttributeError: missing attribute: <attribute>
+
+

Where <attribute> is the atrribute 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)").

+
+

5. 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:

+
+
+
Client.all(:limit => 5)
+

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:

+
+
+
SELECT * FROM clients LIMIT 5
+
+
+
Client.all(:limit => 5, :offset => 5)
+

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:

+
+
+
SELECT * FROM clients LIMIT 5, 5
+
+

6. 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:

+
+
+
Order.all(:group => "date(created_at)", :order => "created_at")
+

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:

+
+
+
SELECT * FROM orders GROUP BY date(created_at)
+
+

7. 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:

+
+
+
Order.all(:group => "date(created_at)", :having => ["created_at > ?", 1.month.ago])
+

This will return single order objects for each day, but only for the last month.

+
+

8. 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:

+
+
+
Client.first(:readonly => true)
+

If you assign this record to a variable client, calling the following code will raise an ActiveRecord::ReadOnlyRecord exception:

+
+
+
client = Client.first(:readonly => true)
+client.locked = false
+client.save
+
+

9. 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.

+
+
+
Topic.transaction do
+  t = Topic.find(params[:id], :lock => true)
+  t.increment!(:views)
+end
+

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:

+
+
+
Topic.transaction do
+  t = Topic.find(params[:id], :lock => "LOCK IN SHARE MODE")
+  t.increment!(:views)
+end
+
+

10. 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.

+
+

11. 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:

+
+
+
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))
+

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:

+
+
+
+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
+

This query is more efficent, 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):

+
+
+
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”)
+

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:

+
+
+
Client.first(:include => "orders", :conditions =>
+  ["orders.created_at >= ? AND orders.created_at <= ?", 2.weeks.ago, Time.now])
+
+

12. 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"):

+
+
+
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
+

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:

+
+
+
client = Client.find_or_initialize_by_name('Ryan')
+

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.

+
+

13. 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:

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

find_by_sql provides you with a simple way of making custom calls to the database and retrieving instantiated objects.

+
+

14. 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.

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

15. 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.

+
+

16. 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.

+

16.1. Simple Named Scopes

+

Suppose we want to find all clients who are male. You could use this code:

+
+
+
class Client < ActiveRecord::Base
+  named_scope :males, :conditions => { :gender => "male" }
+end
+

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:

+
+
+
class Client < ActiveRecord::Base
+  named_scope :active, :conditions => { :active => true }
+end
+

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.

+

16.2. Combining Named Scopes

+

If you wanted to find all the clients who are active and male you can stack the named scopes like this:

+
+
+
Client.males.active.all
+

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:

+
+
+
Client.males.active.all(:conditions => ["age > ?", params[:age]])
+

16.3. Runtime Evaluation of Named Scope Conditions

+

Consider the following code:

+
+
+
class Client < ActiveRecord::Base
+  named_scope :recent, :conditions => { :created_at > 2.weeks.ago }
+end
+

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:

+
+
+
class Client < ActiveRecord::Base
+  named_scope :recent, lambda { { :conditions => ["created_at > ?", 2.weeks.ago] } }
+end
+

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.

+

16.4. Named Scopes with Multiple Models

+

In a named scope you can use :include and :joins options just like in find.

+
+
+
class Client < ActiveRecord::Base
+  named_scope :active_within_2_weeks, :joins => :order,
+    lambda { { :conditions => ["orders.created_at > ?", 2.weeks.ago] } }
+end
+

This method, called as Client.active_within_2_weeks.all, will return all clients who have placed orders in the past 2 weeks.

+

16.5. Arguments to Named Scopes

+

If you want to pass to a named scope a required arugment, just specify it as a block argument like this:

+
+
+
class Client < ActiveRecord::Base
+  named_scope :recent, lambda { |time| { :conditions => ["created_at > ?", time] } }
+end
+

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 *.

+
+
+
class Client < ActiveRecord::Base
+  named_scope :recent, lambda { |*args| { :conditions => ["created_at > ?", args.first || 2.weeks.ago] } }
+end
+

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.

+

16.6. Anonymous Scopes

+

All Active Record models come with a named scope named scoped, which allows you to create anonymous scopes. For example:

+
+
+
class Client < ActiveRecord::Base
+  def self.recent
+    scoped :conditions => ["created_at > ?", 2.weeks.ago]
+  end
+end
+

Anonymous scopes are most useful to create scopes "on the fly":

+
+
+
Client.scoped(:conditions => { :gender => "male" })
+

Just like named scopes, anonymous scopes can be stacked, either with other anonymous scopes or with regular named scopes.

+
+

17. 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+.

+
+
+
Client.exists?(1)
+

The exists? method also takes multiple ids, but the catch is that it will return true if any one of those records exists.

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

Further more, exists takes a conditions option much like find:

+
+
+
Client.exists?(:conditions => "first_name = 'Ryan'")
+
+

18. 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:

+
+
+
Client.count(:conditions => "first_name = 'Ryan'")
+

Which will execute:

+
+
+
SELECT count(*) AS count_all FROM clients WHERE (first_name = 'Ryan')
+

You can also use :include or :joins for this to do something a little more complex:

+
+
+
Client.count(:conditions => "clients.first_name = 'Ryan' AND orders.status = 'received'", :include => "orders")
+

Which will execute:

+
+
+
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')
+

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.

+

18.1. 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.

+

18.2. 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:

+
+
+
Client.average("orders_count")
+

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.

+

18.3. 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:

+
+
+
Client.minimum("age")
+

For options, please see the parent section, Calculations

+

18.4. 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:

+
+
+
Client.maximum("age")
+

For options, please see the parent section, Calculations

+

18.5. 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:

+
+
+
Client.sum("orders_count")
+

For options, please see the parent section, Calculations

+
+

19. Changelog

+
+

Lighthouse ticket

+
    +
  • +

    +December 29 2008: Initial version by Ryan Bigg +

    +
    • +
+
diff --git a/railties/doc/guides/html/authors.html b/railties/doc/guides/html/authors.html index a27be1cf343..fc4ef075493 100644 --- a/railties/doc/guides/html/authors.html +++ b/railties/doc/guides/html/authors.html @@ -241,11 +241,11 @@

About the Authors

Cássio Marques

Cássio Marques is a Brazilian software developer working with different programming languages such as Ruby, JavaScript, C++ and Java, as an independent consultant. He blogs at http://cassiomarques.wordpress.com, which is mainly written in portuguese, but will soon get a new section for posts with english translation.

-
-
-
Pratik Naik
-

Pratik Naik is an independent Ruby on Rails consultant and also a member of the Rails core team. He blogs semi-regularly at has_many :bugs, :through => :rails and has an active twitter account .

-
+
+
+
Pratik Naik
+

Pratik Naik is an independent Ruby on Rails consultant and also a member of the Rails core team. He blogs semi-regularly at has_many :bugs, :through => :rails and has an active twitter account .

+
diff --git a/railties/doc/guides/html/index.html b/railties/doc/guides/html/index.html index a8d01ddfacd..b946fd5d285 100644 --- a/railties/doc/guides/html/index.html +++ b/railties/doc/guides/html/index.html @@ -260,7 +260,7 @@

Models

-
Active Record Query Interface
+
Active Record Query Interface
@@ -269,7 +269,7 @@

Models

Lighthouse Ticket
-

This guide covers the database query interface provided by Active Record.

+

This guide covers the database query interface provided by Active Record.

Views

@@ -349,7 +349,7 @@

Digging Deeper

Performance Testing Rails Applications
-

This guide covers ways to benchmark and profile your Rails application.

+

This guide covers ways to benchmark and profile your Rails application.

diff --git a/railties/doc/guides/html/performance_testing.html b/railties/doc/guides/html/performance_testing.html index 817b9dbe847..55b181dccda 100644 --- a/railties/doc/guides/html/performance_testing.html +++ b/railties/doc/guides/html/performance_testing.html @@ -574,7 +574,7 @@

1.7. Performance Test Environment

ActionController::Base.perform_caching = true
 ActiveSupport::Dependencies.mechanism = :require
 Rails.logger.level = ActiveSupport::BufferedLogger::INFO
-

As ActionController::Base.perform_caching is set to true, performance tests will behave much as they do in the production environment.

+

As ActionController::Base.perform_caching is set to true, performance tests will behave much as they do in the production environment.

1.8. Installing GC-Patched Ruby

To get the best from Rails performance tests, you need to build a special Ruby binary with some super powers - GC patch for measuring GC Runs/Time and memory/object allocation.

The process is fairly straight forward. If you’ve never compiled a Ruby binary before, follow these steps to build a ruby binary inside your home directory:

@@ -879,7 +879,7 @@

7. Changelog

  • -January 9, 2009: Complete rewrite by Pratik +January 9, 2009: Complete rewrite by Pratik

  • diff --git a/railties/doc/guides/html/rails_on_rack.html b/railties/doc/guides/html/rails_on_rack.html index a1ecd978b61..a78d1697b01 100644 --- a/railties/doc/guides/html/rails_on_rack.html +++ b/railties/doc/guides/html/rails_on_rack.html @@ -233,6 +233,8 @@

    Chapters

  • Generating a Metal Application
    • +
  • Execution Order
    • +
  • @@ -465,31 +467,31 @@

    3.2. Internal Middleware Stack

    ActionController::Lock

    -

    Mutex

    +

    Sets env["rack.multithread"] flag to true and wraps the application within a Mutex.

    ActionController::Failsafe

    -

    Never fail

    +

    Returns HTTP Status 500 to the client if an exception gets raised while dispatching.

    ActiveRecord::QueryCache

    -

    Query caching

    +

    Enable the Active Record query cache.

    ActionController::Session::CookieStore

    -

    Query caching

    +

    Uses the cookie based session store.

    ActionController::Session::MemCacheStore

    -

    Query caching

    +

    Uses the memcached based session store.

    ActiveRecord::SessionStore

    -

    Query caching

    +

    Uses the database based session store.

    ActionController::VerbPiggybacking

    -

    _method hax

    +

    Sets HTTP method based on _method parameter or env["HTTP_X_HTTP_METHOD_OVERRIDE"].

    @@ -571,6 +573,30 @@

    4.1. Generating a Metal Application

    end end

    • Metal applications are an optimization. You should make sure to understand the related performance implications before using it.

    +

    4.2. Execution Order

    +

    All Metal Applications are executed by Rails::Rack::Metal middleware, which is a part of the ActionController::MiddlewareStack chain.

    +

    Here’s the primary method responsible for running the Metal applications:

    +
    +
    +
    def call(env)
+  @metals.keys.each do |app|
+    result = app.call(env)
+    return result unless result[0].to_i == 404
+  end
+  @app.call(env)
+end
    +

    In the code above, @metals is an ordered ( alphabetical ) hash of metal applications. Due to the alphabetical ordering, aaa.rb will come before bbb.rb in the metal chain.

    +
    + + + +
    +Important +Metal applications cannot return the HTTP Status 404 to a client, as it is used for continuing the Metal chain execution. Please use normal Rails controllers or a custom middleware if returning 404 is a requirement.
    +

    5. Middlewares and Rails

    @@ -581,7 +607,7 @@

    6. Changelog

    • -January 11, 2009: First version by Pratik +January 11, 2009: First version by Pratik

    diff --git a/railties/doc/guides/source/rails_on_rack.txt b/railties/doc/guides/source/rails_on_rack.txt index 6607c88928d..a06d399cc5a 100644 --- a/railties/doc/guides/source/rails_on_rack.txt +++ b/railties/doc/guides/source/rails_on_rack.txt @@ -136,13 +136,13 @@ use ActionController::VerbPiggybacking [options="header"] |========================================================================================================== |Middleware |Purpose -|ActionController::Lock | Mutex -|ActionController::Failsafe | Never fail -|ActiveRecord::QueryCache | Query caching -|ActionController::Session::CookieStore | Query caching -|ActionController::Session::MemCacheStore | Query caching -|ActiveRecord::SessionStore | Query caching -|ActionController::VerbPiggybacking | _method hax +|ActionController::Lock | Sets +env["rack.multithread"]+ flag to +true+ and wraps the application within a Mutex. +|ActionController::Failsafe | Returns HTTP Status +500+ to the client if an exception gets raised while dispatching. +|ActiveRecord::QueryCache | Enable the Active Record query cache. +|ActionController::Session::CookieStore | Uses the cookie based session store. +|ActionController::Session::MemCacheStore | Uses the memcached based session store. +|ActiveRecord::SessionStore | Uses the database based session store. +|ActionController::VerbPiggybacking | Sets HTTP method based on +_method+ parameter or +env["HTTP_X_HTTP_METHOD_OVERRIDE"]+. |========================================================================================================== === Customizing Internal Middleware Stack === @@ -228,9 +228,28 @@ end Metal applications are an optimization. You should make sure to http://weblog.rubyonrails.org/2008/12/20/performance-of-rails-metal[understand the related performance implications] before using it. -== Middlewares and Rails == +=== Execution Order === + +All Metal Applications are executed by +Rails::Rack::Metal+ middleware, which is a part of the +ActionController::MiddlewareStack+ chain. +Here's the primary method responsible for running the Metal applications: +[source, ruby] +---------------------------------------------------------------------------- +def call(env) + @metals.keys.each do |app| + result = app.call(env) + return result unless result[0].to_i == 404 + end + @app.call(env) +end +---------------------------------------------------------------------------- + +In the code above, +@metals+ is an ordered ( alphabetical ) hash of metal applications. Due to the alphabetical ordering, +aaa.rb+ will come before +bbb.rb+ in the metal chain. + +IMPORTANT: Metal applications cannot return the HTTP Status +404+ to a client, as it is used for continuing the Metal chain execution. Please use normal Rails controllers or a custom middleware if returning +404+ is a requirement. + +== Middlewares and Rails == == Changelog ==