diff options
Diffstat (limited to 'railties/doc/guides')
| -rw-r--r-- | railties/doc/guides/activerecord/finders.txt | 61 |
1 files changed, 1 insertions, 60 deletions
diff --git a/railties/doc/guides/activerecord/finders.txt b/railties/doc/guides/activerecord/finders.txt index 7f486f899c..2547ae3f26 100644 --- a/railties/doc/guides/activerecord/finders.txt +++ b/railties/doc/guides/activerecord/finders.txt @@ -1,7 +1,6 @@ Rails Finders ============= -== What you will learn == This guide is all about the `find` method defined in ActiveRecord::Base, finding on associations, and associated goodness such as named scopes. You will learn how to be a find master. == In the beginning... @@ -9,12 +8,10 @@ This guide is all about the `find` method defined in ActiveRecord::Base, finding In the beginning there was SQL. SQL looked like this: [source,sql] -------------------------------------------------------- SELECT * FROM clients SELECT * FROM clients WHERE id = '1' SELECT * FROM clients LIMIT 0,1 SELECT * FROM clients ORDER BY id DESC LIMIT 0,1 -------------------------------------------------------- In Rails you don't usually have to type SQL (unlike other languages) because ActiveRecord is there to help you find your records. @@ -23,41 +20,31 @@ In Rails you don't usually have to type SQL (unlike other languages) because Act For this guide we have the following models: [source,ruby] -------------------------------------------------------- class Client < ActiveRecord::Base has_one :address has_one :mailing_address has_many :orders has_and_belongs_to_many :roles -end -------------------------------------------------------- +end [source,ruby] -------------------------------------------------------- class Address < ActiveRecord::Base belongs_to :client end -------------------------------------------------------- [source,ruby] -------------------------------------------------------- class MailingAddress < Address end -------------------------------------------------------- [source,ruby] -------------------------------------------------------- class Order < ActiveRecord::Base belongs_to :client, :counter_cache => true end -------------------------------------------------------- [source,ruby] -------------------------------------------------------- class Role < ActiveRecord::Base has_and_belongs_to_many :clients end -------------------------------------------------------- == Database Agnostic @@ -68,61 +55,45 @@ ActiveRecord will perform queries on the database for you and is compatible with ActiveRecord::Base has methods defined on it to make interacting with your database and the tables within it much, much easier: 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: [source, sql] -------------------------------------------------------- SELECT * FROM `clients` WHERE (`clients`.`id` = 1) -------------------------------------------------------- NOTE: Please be aware that because this is a standard table created from a migration in Rails that 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: [source, sql] -------------------------------------------------------- SELECT * FROM `clients` WHERE (`clients`.`id` IN (1,2)) -------------------------------------------------------- [source,txt] -------------------------------------------------------- >> 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 an object of Client. If you wanted to find the first client you would simply type `Client.find(:first)` and that would find the first client created in your clients table: [source,txt] -------------------------------------------------------- >> Client.find(: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 running script/server you may see the following output: [source,sql] -------------------------------------------------------- SELECT * FROM clients LIMIT 1 -------------------------------------------------------- Indicating the query that Rails has performed on your database. To find the last client you would simply type `Client.find(:last)` and that would find the last client created in your clients table: [source,txt] -------------------------------------------------------- >> Client.find(: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"> -------------------------------------------------------- [source,sql] -------------------------------------------------------- SELECT * FROM clients ORDER BY clients.id DESC LIMIT 1 -------------------------------------------------------- To find all the clients you would simply type `Client.find(:all)` and that would find all the clients in your clients table: [source,txt] -------------------------------------------------------- >> Client.find(: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">] -------------------------------------------------------- Alternatively to calling Client.find(:first)/`Client.find(:last)`/`Client.find(:all)`, you could use the class method of `Client.first`/`Client.last`/`Client.all` instead. `Client.first`, `Client.last` and `Client.all` just call their longer counterparts. @@ -145,28 +116,20 @@ To select certain fields, you can use the select option like this: `Client.find( If you want to limit the amount of records to a certain subset of all the records retreived you usually use limit for this, sometimes coupled with offset. Limit is the maximum number of records that will be retreived 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: [source, ruby] -------------------------------------------------------- Client.find(:all, :limit => 5) -------------------------------------------------------- This code will return a maximum of 5 clients and because we've specified no offset it will return the first 5 clients in the table. The SQL it executes will look like this: [source,sql] -------------------------------------------------------- SELECT * FROM clients LIMIT 5 -------------------------------------------------------- [source, ruby] -------------------------------------------------------- Client.find(:all, :limit => 5, :offset => 5) -------------------------------------------------------- This code will return a maximum of 5 clients and because we have specified an offset this time, it will return these records starting from the 5th client in the clients table. The SQL looks like: [source,sql] -------------------------------------------------------- SELECT * FROM clients LIMIT 5, 5 -------------------------------------------------------- == Group @@ -175,18 +138,14 @@ SELECT * FROM clients LIMIT 5, 5 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` error. To set this option, specify it like this: [source, ruby] -------------------------------------------------------- Client.find(:first, :readonly => true) -------------------------------------------------------- If you assign this record to a variable `client` calling the following code will raise an ActiveRecord::ReadOnlyRecord [source, ruby] -------------------------------------------------------- client = Client.find(:first, :readonly => true) client.locked = false client.save -------------------------------------------------------- == Lock @@ -199,20 +158,16 @@ You can chain these options together in no particular order as ActiveRecord will Eager loading is loading associated records along with any number of records in as few queries as possible. Lets say for example if we wanted to load all the addresses associated with all the clients all in the same query we would use `Client.find(:all, :include => :address)`. If we wanted to include both the address and mailing address for the client we would use `Client.find(:all), :include => [:address, :mailing_address]). Inclue 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: [source, 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)) -------------------------------------------------------- The numbers `13` and `14` in the above SQL are the ids of the clients gathered from the `Client.find(: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. An alternative (and more efficient) way to do eager loading is to use the joins option. For example if we wanted to get all the addresses for a client we would do `Client.find(:all, :joins => :address)` and if we wanted to find the address and mailing address for that client we would do `Client.find(:all, :joins => [:address, :mailing_address])`. This is more efficient because it does all the SQL in one query, as shown by this example: [source, 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 -------------------------------------------------------- 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. == Dynamic finders @@ -222,19 +177,15 @@ With every field (also known as an attribute) you define in your table, ActiveRe There's another set of dynamic finders that let you find or create/initialize objects if they aren't find. 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')`: [source,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 -------------------------------------------------------- `find_or_create`'s sibling, find_or_initialize, will find an object and if it does not exist will call `new` with the parameters you passed in. For example: [source, ruby] -------------------------------------------------------- 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 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. @@ -247,51 +198,41 @@ When you define a has_many association on a model you get the find method and dy There was mention of named scopes earlier in "First, Last and All" where we covered the named scopes of `first`, `last` and `all` which were aliases of `find(:first)`, `find(:last)`, `find(:all)` respectively. Now we'll cover adding named scopes to the models in the application. Let's say we want to find all clients who are not locked to do this we would use this code: [source,ruby] -------------------------------------------------------- class Client < ActiveRecord::Base named_scope :unlocked, :conditions => { :locked => false } end -------------------------------------------------------- We would call this new named_scope by doing `Client.unlocked` and this will do the same query as if we just used `Client.find(:all, :conditions => ["unlocked = ?", false])`. Please be aware that the conditions syntax in named_scope and find is different and the two are not interchangeable. If you want to find the first client within this named scope you could do `Client.first.unlocked`. This is possible because named scopes are stackable. Now observe the following code: [source, ruby] -------------------------------------------------------- class Client < ActiveRecord::Base named_scope :recent, :conditions => { :created_at > 2.weeks.ago } end -------------------------------------------------------- What we see here is what looks to be 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: [source, ruby] -------------------------------------------------------- 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, because it's wrapped in a lambda block this code will be parsed every time so you'll get actually 2 weeks ago from the code execution, not 2 weeks ago from the time the model was loaded. If you want to pass a named scope a compulsory argument, just specify it as a block parameter like this: [source, ruby] -------------------------------------------------------- class Client < ActiveRecord::Base named_scope :recent, lambda { |time| { :conditions => ["created_at > ?", time] } } } end -------------------------------------------------------- This will work if we call `Client.recent(2.weeks.ago)` but not if we call `Client.recent`. If we want to add an optional argument for this, we have to use the splat operator as the block's parameter. [source, ruby] -------------------------------------------------------- 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)` and `Client.recent` with the latter always returning records with a created_at date between right now and 2 weeks ago. |