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. Use Model.find(:first,
*args) or its shortcut Model.first(*args).

Find last - This will return the last 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. Use Model.find(:last,
*args) or its shortcut Model.last(*args).

Find all - This will return all the records matched by the options used. If
no records are found, an empty array is returned. Use Model.find(:all,
*args) or its shortcut Model.all(*args).

:group - An attribute name by which the result should be grouped.
Uses the GROUP BY SQL-clause.

:having - Combined with :group this can be used to filter
the records that a GROUP BY returns. Uses the HAVING
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), named associations
in the same form used for the :include option, which will perform
an INNER JOIN on the associated table(s), or an array containing a
mixture of both strings and named associations. 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. 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. Takes a string with the SELECT SQL fragment (e.g. “id,
name”).

:from - By default, this is the table name of the 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.

Examples

# 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.where("administrator = 1").order("created_on DESC").find(1)

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

# find first
Person.first# returns the first object fetched by SELECT * FROM people
Person.where(["user_name = ?",user_name]).firstPerson.where(["user_name = :u",{:u=>user_name}]).firstPerson.order("created_on DESC").offset(5).first# find last
Person.last# returns the last object fetched by SELECT * FROM people
Person.where(["user_name = ?",user_name]).lastPerson.order("created_on DESC").offset(5).last# find all
Person.all# returns an array of objects for all the rows fetched by SELECT * FROM people
Person.where(["category IN (?)",categories]).limit(50).allPerson.where({:friends=>["Bob","Steve","Fred"]}).allPerson.offset(10).limit(10).allPerson.includes([:account,:friends]).allPerson.group("category").all

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.