A Quick Reference on Rails Active-Record CRUD Operations
By Monica Chaturvedi<immcse@gmail.com>
Dynamic Attribute Based Finders:
Append attribute to find_by_/find_all_by_

Find by single attribute:
User.find_by_email(“a@b.c”)

Find by several attributes:
User.find_by_email_and_password(“a@b.c”,
“pass”,Options) #or isn’t allowed!

Find or Initialize:
If record exists, returns it. Else returns a
new record without saving it first.
User.find_or_initialize_by_email("a@b.c")

Find or Create:
Creates a new record unless it exists.
User.find_or_create_by_email("a@b.c")
Conditions:
To represent the WHERE part of sql query.

String: conditions can be specified in a string.
:conditions => "email = '#{email}'" #unsafe

Array:
:conditions => [ "email = ? AND password = ?",
email, password ] " #safe & sanitized

Arrays with symbols:
:conditions=>[array, {Hash_of _symbols}]
:conditions => ["id = :id OR email = :email",{ :id
=> 3, :email => "a@b.c"}]

Hash:
:conditions => { :email => email, :password =>
password } #safe & sanitized; #will generate
AND in sql.

Specifying Range inside hash:
:conditions => { :age => a..b }) #inclusive
CRUD-Read- Calculations
To perform aggregate operations

calculate(operation, column_name, options)

average(column_name, options)

count(*args)

maximum(column_name, options)

minimum(column_name,)

sum(column_name, options)
Options include :distinct.
AR Constructors:
An AR object can be created as follows:

Hash: Supplying constructor parameters in a
hash:
user = User.new(:name => "David", :occupation =>
"Artist")

Block: Using blocks to initialize:
user = User.new do |u|
u.name = "David"
end

Simple:
user = User.new
user.name = "Manni"
CRUD-Update

Increment_counter(attribute,id):
Increments the specified attribute by 1
Ex: Post.increment_counter(:votes, 5) #increments the
col “votes” for postId 5

decrement_counter(attribute,id):
Decrements the specified attribute by 1
Ex: Post. decrement_counter(:votes, 5) # #decrement
the col “votes” for postId 5

save(): If new record: Saves else: updates

save!(): Raises a RecordNotSaved exception if
unable to save.

toggle(attribute): Toggles the attribute’s value
between true and false.

toggle!(attribute): Toggles the attribute and saves it
to Db.

update_attribute(name, value): updates a single
attribute and saves the record

update_attributes(attribute_hash)
updates attributes from the passed in hash and
saves the record.
find_by_sql:
Executes a custom sql query against the
database. Columns are returned as attributes of
the calling Model.
Ex: Post.find_by_sql “select a,b,c,d,e,f from
tablename” #read post.a,post.b etc
CRUD-Read- find(*args)
Retrieves objects from database by converting the specified criteria into SQL
statements. Then it takes the results returned from the database and instantiates
them as ActiveRecord objects.
Syntax: Person.find(primary_key_value,Options)

find(id): returns first record matching the id
Ex: Member.find_by_id (1), Member.find (1,5,9), Member.find ([1,5,9]). #Exception
RecordNotFound unless record exists.

find(:first, Options): returns first record matching the Options.
Ex: Member.find(:first) #returns nil unless record exists

find(:all, Options): returns all the records matching the Options.
Ex: Member.find(:all) #return an empty array unless members exist.
Options Hash:
Specifies additional parameters as hash object. Following are the valid options for find:

:conditions: Specify conditions to put in WHERE clause.
Ex: Post.find(:conditions=>{:isVisible= >1})=select * from Posts where isVisible=1

:order: Specify SQL order by criteria.
Ex: Post.find(:all,:order =>”colmn desc”)=select * from Post order by colmn desc

:group: An attribute name by which the result should be grouped.
Ex: Post.find(:all,:group=>”member_id”=select * from Post group by member_id

:limit: Limits the no. of rows to be returned.
Ex: Post.find(:all,limit=>10)|= select * from Post Limit 10

:offset: An integer determining the offset from where the rows should be fetched. Ex:
Post.find(:offset=>5) #skip rows 0 through 4.

:select: Specify list of columns to retrieve.
Ex: Post.find(:all, :select => "email,id ")=select email,id form posts

:include: Names associations that should be loaded alongside using LEFT OUTER JOINs. For ex,
loading members along with posts saves a roundtrip in each loop.
Ex: Post.find(:all, :include=>[:member]) #loads member details along with post details

:from: Table or View name to select from.
Ex: Post.find(:all,:from=>”MemberPosts”) #select * from MemberPosts

:readonly: To create a reader
Ex: Post.find(:all, :readonly=>true)

:lock: Implement row level locking.
Ex: Post.find(l, :lock=>true) #implements select for ..update command

:join: An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id =
id"
Ex: Post.find(:all, :joins=>"JOIN topics ON posts.topic_id=topics.id JOIN authors ON
topics.author_id=authors.id")