In the beginning there was SQL. SQL looked like this:

In Rails you don't usually have to type SQL (unlike other languages) because ActiveRecord is there to help you find your records.

For this guide we have the following models:

ActiveRecord 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 ActiveRecord method format will always be the same.

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:

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:

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:

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:

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

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.

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.

If you'd like to add conditions to your find, you could just specify them in there, just like Client.find(:first, :conditions ⇒ "orders_count = 2"). Now what if that number could vary, say as a parameter from somewhere, or perhaps from the user's level status somewhere? The find then becomes something like Client.find(:first, :conditions ⇒ ["orders_count = ?", params[:orders]]). ActiveRecord 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.find(: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 true and this will find the first record in the table that has 2 as its value for the orders_count field and false for its locked field.

The reason for doing code like:

instead of:

Client.find(:first, :conditions ⇒ "orders_count = #{params[:orders]}")

is because of parameter safety. Putting the variable directly into the conditions string will parse the variable 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 parameters directly inside the conditions string.

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 we had two dates coming in from a controller we could do something like this to look for a range:

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.

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:

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

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:

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

Just like in Ruby.

If you're getting a set of records and want to force an order, you can use Client.find(:all, :order ⇒ "created_at") which by default will sort the records by ascending order. If you'd like to order it in descending order, just tell it to do that using Client.find(:all, :order ⇒ "created_at desc")

To select certain fields, you can use the select option like this: Client.find(: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 0,1 on your database.

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:

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:

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:

TODO

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:

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

If you're wanting to stop race conditions for a specific record, say for example you're incrementing a single field for a record you can use the lock option to ensure that the record is updated correctly. It's recommended this be used inside a transaction.

You can chain these options together in no particular order as ActiveRecord will write the correct SQL for you. If you specify two instances of the same options inside the find statement ActiveRecord will use the latter.

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:

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:

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.

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:

With every field (also known as an attribute) you define in your table, ActiveRecord provides finder methods for these. 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 ActiveRecord. If you have also have a locked field on the client model, you also get find_by_locked and find_all_by_locked. 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). These finders are an excellent alternative to using the conditions option, mainly because it's shorter to type find_by_name(params[:name]) than it is to type find(:first, :conditions ⇒ ["name = ?", params[:name]]).

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

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:

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.

If you'd like to use your own SQL to find records a table you can use find_by_sql. find_by_sql will return an array of objects even if it only returns a single record in it's call to the database. For example you could run this query:

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

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

In this section we'll cover adding named scopes to the models in the application. Let's say we want to find all clients who are male we would use this code:

And we could call it like Client.males to get all the clients who are male.

If we wanted to find all the clients who are active, we could use this:

We would call this new named_scope by doing Client.active and this will do the same query as if we just used Client.find(:all, :conditions ⇒ ["active = ?", true]). 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.active.first.

and then if we wanted to find all the clients who are active and male we could stack the named scopes like this:

If you would then like to do a find on that subset of clients, you can. Just like an association, named scopes allow you to call find on a set of records:

Now observe the following code:

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:

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.

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

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

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

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.

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.

Remember that named scopes are stackable, so you will be able to do Client.recent(2.weeks.ago).unlocked to find all clients created between right now and 2 weeks ago and have their locked field set to false.

If you simply want to check for the existance 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.

The above code will check for the existance of a clients table record with the id of 1 and return true if it exists.

exists? also takes multiple ids, as shown by the above code, but the catch is that it will return true if any one of those records exists.

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

If you want to see how many records are in your models 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).

count takes conditions much in the same way exists? does:

TODO

Thanks to Ryan Bates for his awesome screencast on named scope #108. The information within the named scope section is intentionally similar to it, and without the cast may have not been possible.

Thanks to Mike Gunderloy for his tips on creating this guide.