rails ActiveRecord find/count

 find/find_by_attributesName/find_all_by_attributesName/find(:first,:conditions=>)/find(:first,:conditions=>)/count

 

find( * args) 
Find operates  with  three different retrieval approaches: 

Find by id: This can either be a specific id ( 1 ), a list  of  ids ( 1 ,  5 ,  6 ),  or  an array  of  ids ([ 5 ,  6 ,  10 ]).  If  no record can be found  for  all  of  the listed ids,  then  RecordNotFound will be raised. 
Find first: This will  return  the first record matched by the options used. These options can either be specific conditions  or  merely an order.  If  no record can be matched, nil  is  returned. 
Find all: This will  return  all the records matched by the options used.  If  no records are found, an empty array  is  returned. 
All approaches accept an options hash  as  their last parameter. The options are: 

:conditions: An SQL fragment like  " administrator = 1 "   or  [  " user_name = ? " , username ]. See conditions  in  the intro. 
:order: An SQL fragment like  " created_at DESC, name " . 
:group: An attribute name by which the result should be grouped. Uses the GROUP BY SQL - clause. 
:limit: An  integer  determining the limit  on  the number  of  rows that should be returned. 
:offset: An  integer  determining the offset from where the rows should be fetched. So at  5 , it would skip rows  0  through  4 . 
:joins: Either an SQL fragment  for  additional joins like  " LEFT JOIN comments ON comments.post_id = id "  (rarely needed)  or  named associations  in  the same form used  for  the :include  option , which will perform an INNER  JOIN   on  the associated table(s).  If  the value  is  a  string ,  then  the records will be returned read - only since they will have attributes that  do   not  correspond  to  the table‘s columns. Pass : readonly   =>   false   to  override. 
:include: Names associations that should be loaded alongside  using   LEFT  OUTER JOINs. The symbols named refer  to  already defined associations. See eager loading under Associations. 
: select : By  default , this  is   *   as   in   SELECT   *  FROM, but can be changed  if  you,  for  example, want  to   do  a  join  but  not  include the joined columns. 
:from: By  default , this  is  the table name  of  the  Class , class, but can be changed to an alternate table name (or even the name of a database view). 
:readonly: Mark the returned records read-only so they cannot be saved or updated. 
:lock: An SQL fragment like "FOR UPDATE" or "LOCK IN SHARE MODE". :lock => true gives connection‘s default exclusive lock, usually "FOR UPDATE". 
Examples for find by id: 

  Person.find(1)       # returns the object for ID = 1
  Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
  Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
  Person.find([1])     # returns an array for the object with ID = 1
  Person.find(1, :conditions => "administrator = 1", :order => "created_on DESC")
Note that returned records may not be in the same order as the ids you provide since database rows are unordered. Give an explicit :order to ensure the results are sorted. 

Examples for find first: 

  Person.find(:first) # returns the first object fetched by SELECT * FROM people
  Person.find(:first, :conditions => [ "user_name = ?", user_name])
  Person.find(:first, :order => "created_on DESC", :offset => 5)
Examples for find all: 

  Person.find(:all) # returns an array of objects for all the rows fetched by SELECT * FROM people
  Person.find(:all, :conditions => [ "category IN (?)", categories], :limit => 50)
  Person.find(:all, :offset => 10, :limit => 10)
  Person.find(:all, :include => [ :account, :friends ])
  Person.find(:all, :group => "category")
Example for find with a lock. Imagine two concurrent transactions: each will read person.visits == 2, add 1 to it, and save, resulting in two saves of person.visits = 3. By locking the row, the second transaction has to wait until the first is finished; we get the expected person.visits == 4. 

  Person.transaction do
    person = Person.find(1, :lock => true)
    person.visits += 1
    person.save!
  end

 

count_by_sql(sql) 
Returns the result  of  an SQL statement that should only include a COUNT( * )  in  the  SELECT  part. The use  of  this method should be restricted  to  complicated SQL queries that can‘t be executed  using  the ActiveRecord::Calculations  Class methods class methods. Look into those before using this. 

Options
sql: An SQL statement which should return a count query from the database, see the example below 

Examples
  Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"