find

Check ActiveRecord::Base.method_missing for documentation on the family of "magic" find methods (find_by_x, find_all_by_x, find_or_create_by_x, etc.).

Say you have tables "authors" and "books" and they have a one-to-many association.

You want authors who have written books with "cooking" in the title...

cookbook_authors = Author.find(:all, 
:conditions => ['books.title LIKE ?', '%cooking%'], 
:joins => [:books], 
:order => 'authors.last_name' )

For many-to-many associations, it's a similar pattern. Say you have tables "people" and "organizations" with a many-to-many association through the join table "organization_memberships".

Ski Club members whose first name starts with "a"...

ski_club_members = Person.find(:all, 
:conditions => ['first_name LIKE ? AND organizations.name = ?', 
  'a%', 'Ski Club'], 
:joins => [:organizations], 
:order => 'people.last_name' )

When you use the :joins option you can get multiple instances of the same item. For example, say you want every User who owns one or more Lists. With the code below, if a user owns 5 lists, the User will show up five times in the results:

users = User.find(:all, 
:conditions => ['users.id = lists.user_id'], 
:joins => [:lists], 
:order => 'users.username')

You can cause each found user to appear only once by using the :select option with "DISTINCT":

users = User.find(:all, 
:conditions => ['users.id = lists.user_id'], 
:joins => [:lists], 
:select => 'DISTINCT users.*'
:order => 'users.username')

It's easy to join multiple tables too. In this case we have:

class Article
belongs_to :feed
end

class Feed
has_many :articles
belongs_to :source
end

class Source
has_many :feeds
# t.bool :visible
end

You can search articles and specify a condition on the sources table.

Article.find(:all, 
:conditions => { :feeds => { :sources => { :visible => true }}}, 
:joins => [:feed => :source],

You can access aggregate methods (such as +SUM+, +COUNT+, etc.) when using a +JOIN+ and GROUP BY query by simply naming the aggregate columns and calling them as methods on the returned objects:

hits_by_page = WebpageHit.all({ :select => "webpages.*, COUNT(webpage_hit.id) AS view_count", :joins => :webpage, :group => "webpages.id" }) homepage_hits = hits_by_page[homepage.id].view_count

The +view_count+ method is added to the +Webpage+ model by this call. Note, however, that this method returns a string, and is not typecasted by Rails.

:conditions => {:login => login, :password => password}

:conditions => ['subject LIKE :foo OR body LIKE :foo', {:foo => 'woah'}]

(from the book "The Rails Way")

=== class Issue < ActiveRecord::Base has_many :journals end

class Journal < ActiveRecord::Base
belongs_to :issue
has_many :details, :class_name => "JournalDetail", :dependent => :delete_all
end

class JournalDetail < ActiveRecord::Base
belongs_to :journal
end

issue = Issue.find(:first, :include => {:journals => :details}

log record follow:

SELECT * FROM `issues` LIMIT 1
SELECT `journals`.* FROM `journals` WHERE (`journals`.`journalized_id` IN (1) and `journals`.`journalized_type` = 'Issue' AND (dustbin <> 1))
SELECT `journal_details`.* FROM `journal_details` WHERE (`journal_details`.journal_id IN (1,2,876177898,935815637))

when execute follow code, then not build sql sentent:

issue.journals
issue.journals[0].details

A couple of comments on the comments:

The created_at/created_on thing clearly relates to the columns that have been defined in your model -- it's got nothing to do with Rails 2.1 (although the Rails 2 "timestamp" method adds the created_at column).

And find(:first), find(:last) return model objects, rather than arrays/result sets, which is why you can't do a map on them -- you can't do anything that you would do on an Enumerable, unless the model object itself is Enumerable.

Ordering by RAND() is not a wise idea when you have a large table with lots of rows. Your database will have to calculate a different random value for every row in your database -- O(N) -- then sort the entire table by those values -- O(N log N).

There are a number of better ways to get a random record from your table. Some examples:

• If your table is not sparse, choose a random ID and get that row (or the nearest row):

rand_id = rand(Model.count) rand_record = Model.first(:conditions => [ "id >= ?", rand_id]) # don't use OFFSET on MySQL; it's very slow

• If your table is sparse, or does not have a primary key, consider adding an indexed column of random numbers between 0 and N. You can then order by this column quickly and choose a value using a method similar to the above example.

The :order parameter is not sanitized, so doing something like Person.find( :first , :order => params[:order] ) could get you in trouble.

You can only use .map(&:item) with find(:all, not find(:first. For example; the first works, but the second does not.

@person = Person.find(:all, :conditions => {
:id => @person.id}, :select => "name").map(&:name)

@person = Person.find(:first, :conditions => {
:id => @person.id}, :select => "name").map(&:name)

it might be obvious or not:

Task.find :all, :select => "name, members"

It's as simple as: Things.first(:order => 'RAND()')

Of course depending on your database it could be 'RANDOM()' or something similar.

I have seen how :include does not nessisarily perform a join during that SQL query, if you need the join to occur then, rather then tricking AR ("forcing"), use :joins instead of :include to ensure the joins occur.

How about if you wanted to find a random set of records instead of a singular record, what would be the best way?

Thank you

If you are grouping similar records and paginating you might need to use :group You'll want to :select only the field you're collapsing on probably.

Model.count(:select => :attribute, :group => :attribute)

This will return an OrderedHash of your attributes with a count for each.

{"Column Content" => 6, "Another Column's Content" => 8}

You'll need a second query to pull all of your records out.

If you want to fetch all records when one column (boolean) is set to nil or false, try this:

Project.all(:conditions => "archived IS NULL OR archived = 'f'")

If you want to find any number of records without sorting your entire table randomly every time, try the solution I posted here:

http://rubyglasses.blogspot.com/2010/05/activerecord-find-in-random-order.html

http://railscasts.com/episodes/202-active-record-queries-in-rails-3

Since this is deprecated, one can watch the Railcast for upgrading to 3.x

The equivalent is the ActiveRecord finder methods. http://apidock.com/rails/ActiveRecord/Fixture/find