My Active Record Tests

start gem server and browse to the full documentation http://localhost:8808/doc_root/activerecord-2.0.2/rdoc/index.html Sample table used CREATE TABLE test.users ( id int(10) unsigned NOT NULL auto_increment, name varchar(45) NOT NULL, age int(11) default NULL, PRIMARY KEY (id) ) ENGINE=MyISAM; Table has one record id=1 name=”Sreeprakash”, age=51 Model used user.rb class User < ActiveRecord::Base end Controller used users_controller.rb class UsersController < ApplicationController # we will fill test functions to test the ActiveRecord methods end No Views used Browser URLhttp://localhost:3000/users/test

• Read one record/field with ID = 1 def test render :text => “Hello ” + User.find(1).name end Results: Hello Sreeprakash
• Add one record using hash u = User.new( :name => “David”, :age => 42) u.save
• Using block user = User.new do |u| u.name = “David” u.age= 42 end user.save
• Creating a bare record user = User.new user.name = “David” user.age= 42 user.save
• Update an exiting record # 1 User.update(1, :name => “SreeprakashABC”, :age => 51)
• Find a URL passed id URLhttp://localhost:3000/users/test/2 u = User.find(params[:id]) render :text => “Hello ” + u.name (routes.rb must have the line map.connect ‘:controller/:action/:id’ )
• Associations between objects controlled by simple meta-programming macros. class Firm < ActiveRecord::Base has_many :clients has_one :account belongs_to :conglomorate end
• Aggregations of value objects controlled by simple meta-programming macros. class Account < ActiveRecord::Base composed_of :balance, :class_name => “Money”, :mapping => %w(balance amount) composed_of :address, :mapping => [%w(address_street street), %w(address_city city)] end
• Validation rules that can differ for new or existing objects. class Account < ActiveRecord::Base validates_presence_of :subdomain, :name, :email_address, :password validates_uniqueness_of :subdomain validates_acceptance_of :terms_of_service, n => :create validates_confirmation_of :password, :email_address, n => :create end
• Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc).

• class Person &lt; ActiveRecord::Base def before_destroy # is called just before Person#destroy CreditCard.find(credit_card_id).destroy end end class Account &lt; ActiveRecord::Base after_find :eager_load, 'self.class.announce(#{id})' end

  1 2 3 4 5 6 7 8 9

  class Person < ActiveRecord::Base    def before_destroy # is called just before Person#destroy      CreditCard.find(credit_card_id).destroy    end end   class Account < ActiveRecord::Base    after_find :eager_load, 'self.class.announce(#{id})' end

• Observers for the entire lifecycle
  class CommentObserver &lt; ActiveRecord::Observer def after_create(comment) # is called just after Comment#save Notifications.deliver_new_comment("david@loudthinking.com", comment) end end

  1 2 3 4 5

  class CommentObserver < ActiveRecord::Observer    def after_create(comment) # is called just after Comment#save      Notifications.deliver_new_comment("david@loudthinking.com", comment)    end end

• Inheritance hierarchies
  class Company &lt; ActiveRecord::Base; end class Firm &lt; Company; end class Client &lt; Company; end class PriorityClient &lt; Client; end

  1 2 3 4

  class Company < ActiveRecord::Base; end class Firm < Company; end class Client < Company; end class PriorityClient < Client; end

• Transaction support on both a database and object level. The latter is implemented by using Transaction::Simple
  # Just database transaction Account.transaction do david.withdrawal(100) mary.deposit(100) end # Database and object transaction Account.transaction(david, mary) do david.withdrawal(100) mary.deposit(100) end

  1 2 3 4 5 6 7 8 9 10 11

  # Just database transaction   Account.transaction do     david.withdrawal(100)     mary.deposit(100)   end     # Database and object transaction   Account.transaction(david, mary) do     david.withdrawal(100)     mary.deposit(100)   end

• Reflections on columns, associations, and aggregations
  reflection = Firm.reflect_on_association(:clients) reflection.klass # =&gt; Client (class) Firm.columns # Returns an array of column descriptors for the firms table

  1 2 3

  reflection = Firm.reflect_on_association(:clients)   reflection.klass # => Client (class)   Firm.columns # Returns an array of column descriptors for the firms table

• Direct manipulation (instead of service invocation) So instead of (Hibernate example):
  long pkId = 1234; DomesticCat pk = (DomesticCat) sess.load( Cat.class, new Long(pkId) ); // something interesting involving a cat... sess.save(cat); sess.flush(); // force the SQL INSERT

  1 2 3 4 5

  long pkId = 1234;    DomesticCat pk = (DomesticCat) sess.load( Cat.class, new Long(pkId) );    // something interesting involving a cat...    sess.save(cat);    sess.flush(); // force the SQL INSERT

  Active Record lets you:

  pkId = 1234 cat = Cat.find(pkId) # something even more interesting involving the same cat... cat.save

  1 2 3 4

  pkId = 1234    cat = Cat.find(pkId)    # something even more interesting involving the same cat...    cat.save

• Database abstraction through simple adapters (~100 lines) with a shared connector
  ActiveRecord::Base.establish_connection(:adapter =&gt; "sqlite", :database =&gt; "dbfile") ActiveRecord::Base.establish_connection( :adapter =&gt; "mysql", :host =&gt; "localhost", :username =&gt; "me", :password =&gt; "secret", :database =&gt; "activerecord" )

  1 2 3 4 5 6 7 8 9

  ActiveRecord::Base.establish_connection(:adapter => "sqlite", :database => "dbfile")   ActiveRecord::Base.establish_connection(    :adapter  => "mysql",    :host     => "localhost",    :username => "me",    :password => "secret",    :database => "activerecord" )

• Logging support for Log4r and Logger
  ActiveRecord::Base.logger = Logger.new(STDOUT) ActiveRecord::Base.logger = Log4r::Logger.new("Application Log")

  1 2	ActiveRecord::Base.logger = Logger.new(STDOUT)   ActiveRecord::Base.logger = Log4r::Logger.new("Application Log")

• Below are some of the excerpts from the documentation...

  1	Below are some of the excerpts from the documentation...

Simple example (1/2): Defining tables and classes (using MySQL)

Data definitions are specified only in the database. Active Record queries the database for the column names (that then serves to determine which attributes are valid) on regular object instantiation through the new constructor and relies on the column names in the rows with the finders.

Active Record automatically links the “Company” object to the “companies” table

The foreign_key is only necessary because we didn’t use “firm_id” in the data definition

Active Record will also automatically link the “Person” object to the “people” table

Simple example (2/2): Using the domain

Picking a database connection for all the Active Records

Create some fixtures

Lots of different finders

The supertype, Company, will return subtype instances

All the dynamic methods added by the has_many macro

Constrained finds makes access security easier when ID comes from a web-app

Bi-directional associations thanks to the “belongs_to” macro