class MyModel < ActiveRecord::Base
  self.table_name = 'my_legacy_table'
  self.primary_key = 'my_id'
  self.pluralize_table_names = false
  self.table_name_prefix = 'my_app'
end

 # Virtual attributes are attributes that do not correspond
 # directly to database columns.
 class Song < ActiveRecord::Base
  def length=(minutes)
    # self[:length] = minutes*60
    write_attribute(:length, minutes * 60)
  end
 
  def length
    # self[:length] / 60
    read_attribute(:length) / 60
  end
end

class User < ActiveRecord::Base
  def language
    read_attribute(:language) || "sv" 
  end
end

user = User.new(:name => "David")
# user.name? is equivalent to user.name.present?
# If it returns true then the name is not nil and not empty
user.name? # => true

anonymous = User.new(:name => "")
anonymous.name? # => false

  User.find(:first) # => First user object
  User.first # short hand for find(:first)
  User.find(:last) # => Last user object
  User.last # short hand for find(:last)
  User.find(:all) # => Array with all User objects
  User.all # short hand for find(:all)
  User.find(3) # => User object with id 3

User.find(:all, 
  :conditions =>
    ["first_name = ? and created_at > ?", "David", 1.year.ago])

User.find(:all, 
  :conditions => 
    ["first_name = :first_name, last_name = :last_name",
    {:first_name => "David", :last_name => "Letterman"}])
  
User.find(:all, 
  :conditions => {:first_name => "Jamis", :last_name => "Buck"})

User.find(:all, :conditions => [ "category IN (?)", categories])

Post.merge_conditions(
  {:title => 'Lucky Star'},
  ['rating IN (?)', 1..5]
)
=> "(`posts`.`title` = 'Lucky Star') AND (rating IN (1,2,3,4,5))" 

# select * from users limit 1
User.find(:first) <=> User.find(:all, :limit => 1).first

# select * from users where id = 1
User.find(1) <=> User.find(:all, :conditions => "users.id = 1").first

# This works
User.find(:all,
  :conditions => ["name like ?", "%" + params[:name] + "%")

# This doesn't work
User.find(:all,
  :conditions => ["name like '%?%'", params[:name])

User.find_by_first_name "Peter" 
User.find_all_by_last_name "Hanson" 
User.find_by_age "20" 
User.find_by_last_name("Buck",
  :conditions => {:country = "Sweden", :age => 20..30})
User.find_by_first_name_and_last_name "Andreas", "Kviby" 

class Article < ActiveRecord::Base
  named_scope :approved, :conditions => {:status => 'approved'}
  named_scope :since, lambda { |time_ago| { :conditions => ['published_at > ?', time_ago] }}

  named_scope :inactive, :conditions => {:active => false} do
    def activate
      each { |article| article.update_attribute(:active, true) }
    end
  end
end

Article.approved.since(3.days.ago) # all approved articles in the last three days
Article.inactive.activate # activate all inactive articles

User.exists?(999) # => false
User.find(999) # => raises ActiveRecord::RecordNotFound
User.find_by_id(999) # => nil
User.find(:first, :conditions => {:id => 999}) # => nil

# No 'Summer' tag exists
Tag.find_or_create_by_name("Summer") # equal to Tag.create(:name => "Summer")
    
# Now the 'Summer' tag does exist
Tag.find_or_create_by_name("Summer") # equal to Tag.find_by_name("Summer")

# No 'Winter' tag exists
winter = Tag.find_or_initialize_by_name("Winter")
winter.new_record? # true
winter.save

def update_attributes(attributes)
  self.attributes = attributes
  save
end
      
def update_attributes!(attributes)
  self.attributes = attributes
  save!
end

user = User.find_by_name("Dave" )
user.changed? # => false

user.name = "Dave Thomas" 
user.changed? # => true
user.changed # => ['name']
user.changes # => {"name"=>["dave", "Dave Thomas"]}
user.name_changed? # => true

user.name_was # => 'Dave'
user.name_change # => ['Dave', 'Dave Thomas']
user.name = 'Bill'
user.name_change # => ['Dave', 'Dave Thomas']
user.save # updates only the name in the db
user.changed? # => false

# SELECT * FROM accounts WHERE (account.`id` = 1) FOR UPDATE
account = Account.find(id, :lock => true)
account.status = 'disabled'
account.save!

# Optimistic locking with integer column lock_version in the accounts table:
account1 = Account.find(4)
account2 = Account.find(4)
account1.update_attributes(:status => 'disabled')
account2.update_attributes(:status => 'enabled') # => Raises ActiveRecord::StaleObjectError

def destroy(id)
  if id.is_a?(Array)
    id.map { |one_id| destroy(one_id) }
  else
    find(id).destroy
  end
end

def destroy_all(conditions = nil)
  find(:all, :conditions => conditions).each do |object|
    object.destroy
  end
end

#   Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')")
def delete_all(conditions = nil)
  sql = "DELETE FROM #{quoted_table_name} " 
  add_conditions!(sql, conditions, scope(:find))
  connection.delete(sql, "#{name} Delete all")
end

#   Todo.delete(1)
#   Todo.delete([2,3,4])
def delete(id)
  delete_all([ "#{connection.quote_column_name(primary_key)} IN (?)", id ])
end

Person.minimum('age')
Person.maximum('age')
Person.sum('age')
Person.count(:conditions => ["age > ?", 25])
Person.average('age')
Person.calculate(:std, :age)

#   Post.find_by_sql ["SELECT title FROM posts created_at > ?", start_date]
def find_by_sql(sql)
  connection.select_all(sanitize_sql(sql), "#{name} Load").collect! { |record| instantiate(record) }
end

ActiveRecord::Base.connection.execute("delete from users")
ActiveRecord::Base.connection.select_one("select * from users where id = 1")
ActiveRecord::Base.connection.select_all("select * from users")
ActiveRecord::Base.connection.select_value("select name from users where id = 1")
ActiveRecord::Base.connection.select_values("select name from users")

class Person < ActiveRecord::Base
  serialize params
end

person = Person.new
person.params = {
  :height => 190,
  :weight => 80,
  :eye_color => 'blue'
}
person.save # Serializes the hash in YAML format in the db

class Aricle < ActiveRecord::Base
  # Now the body attribute can be accessed with a text method too
  alias_attribute :text, :body
end

a = Article.first
a.body # => "the body" 
a.text # => "the body" 
a.text? # => true

a.text = "new body" 
a.body # => "new body" 

class User < ActiveRecord::Base
  delegate :street, :city, :to => :address
end

u = User.first
u.address.street # => "Fifth Avenue" 
u.street # => "Fifth Avenue" 

class Person < ActiveRecord::Base
  def social_security
    decrypt_social_security
  end
  # Memoize the result of the social_security method after its first evaluation.
  # Must be placed after the target method definition.
  memoize :social_security
end

@person = Person.new
@person.social_security  # decrypt_social_security is invoked
@person.social_security  # decrypt_social_security is NOT invoked

name = Name.new("Dwight" , "D" , "Eisenhower" )
Customer.create(:credit_limit => 1000, :name => name)
customer = Customer.find(:first)
puts customer.name.first #=> Dwight
puts customer.name.last #=> Eisenhower
puts customer.name.to_s #=> Dwight D Eisenhower
customer.name = Name.new("Harry" , nil, "Truman" )
customer.save

Account.transaction do
  account1.deposit(100)
  account2.withdraw(100)
end