1. Table and class
By default,Active Record assumes that the name of the table is the plural form of the name of the class.But you can specify the name of the table which the class is corresponding in class with ‘set_table_name’ method or ‘table_name’ property. For example:
class Sheep < ActiveRecord::Base
set_table_name "sheep" # Not "sheeps"
end
class Order < ActiveRecord::Base
set_table_name "ord_rev99_x" # Wrap a legacy table...
end
class Sheep < ActiveRecord::Base
self.table_name = "sheep"
end
2. APIs of ActiveRecord::Base
All these methods are Singleton method,so you should access these methods though neither an instance, nor the class.
(1)column_names:return all the name of columns in an array.
(2)column_hash[“column_name”]:return the detail of this column
(3)find(primay_key):If given just one primary key,it returns an object containing data for the corresponding row(or throws a RecordNotFound exception).If given multiple primary key values,find returns an array of the corresponding objects.
(4)primay_key:If you override the primary key column’s name with ‘primary_key’ method when you create a table,you can use this property to specify the primary key.For example:
class Book < ActiveRecord::Base
self.primary_key = “column_name”
end
3. Boolean Attribute
To query a column as a Boolean value in a condition,you must append a question mark to the column’s name.
4. Connecting to the Database
One way of specifying the connection is to use the establish_connection class method.For example:
ActiveRecord::Base.establish_connection(
:adapter => “mysql”,
:host => “dbserver.com”
:database => “railsdb”,
:username=> “user”,
:password=> “password”
)
5. Connections and Models
Connections are associated with model classes.Each class inherits the connection of its parent.Because ActiveRecord::Base is the base class of all the Active Record classes,setting a connection for it sets the default connection for all the Active Record Classes you define.However,you can override this when you need to do so.
ActiveRecord::Base.establish_connection(
:adapter => "mysql" ,
:host => "dbserver.com" ,
:database => "online" ,
:username => "groucho" ,
:password => "swordfish" )
class LineItem < ActiveRecord::Base
# ...
end
class Order < ActiveRecord::Base
# ...
end
class Product < ActiveRecord::Base
# ...
end
class Customer < ActiveRecord::Base
establish_connection(
:adapter => "mysql" ,
:host => "dbserver.com" ,
:database => "backend" ,
:username => "chicho" ,
:password => "piano" )
# ...
end
aFinally,you can combine the two approaches(use establish_connection method or configure in database.yml file).If you pass a symbol to establish_connection, Rails looks for a section in database.yml with that name and bases the connection on the parameters found there.This way you can keep all connection details out of your code.
6. CRUD
(1) Create
use ‘new’ method to create an object and call the ‘save’ method of this object to save the data into database.
Active Record constructors take an optional block.If present,the block is invoked with the newly created order as a parameter.This might be useful if you wanted to create and save away an order without creating a new local variable.
Active Record constructors accept a hash of attribute values as an optional parameter. Each entry in this hash corresponds to the name and value of an attribute to be set.
You know that the ‘new’ method creates a new object in memory,we have to invoke ‘save’ method to save the data into database.Active Record has a convenience method,create, that both instantiates the model object and stores it into the database.
You can pass create an array of attribute hashes;it’ll create multiple rows in database and return an array of the corresponding model objects.
The real reason that new and create take a hash of values is that you can construct model objects directly from form parameters.For example:
order = Order.new(params[:order])
(2) Read
l find:
If given just one primary key,it returns an object containing data for the corresponding row(or throws a RecordNotFound exception).If given multiple primary key values,find returns an array of the corresponding objects.
:first and :all --The :first variant of find returns the first row that matches a set of criteria, while the :all form eturns an array of matching rows.
:condition—determines which rows are returned by the find;it corresponds to an SQL where clause.
how to generate dynamic SQL:
One way of specifying placeholders is to insert one or more question marks in the SQL.The first question mark is replaced by the second element of the array,the next question mark by the third,and so on.For example:
name = params[:name]
pos = Order.find(:all,
:conditions => ["name = ? and pay_type = 'po'" , name])
You can alse use named placeholders.
name = params[:name]
pay_type = params[:pay_type]
pos = Order.find(:all,
:conditions => ["name = :name and pay_type = :pay_type" ,
{:pay_type => pay_type, :name => name}])
:order—The :order parameter lets you specify the criteria you’d normally and after the order by keywords.
:limit—You can limit the number of rows returned.
:offset—The :offset parameter goes hand in hand with the :limit parameter.It allows you to specify the the offset of the first row in the result set that will be returned.For example:
def Order.find_on_page(page_num, page_size)
find(:all,
:order => "id" ,
:limit => page_size,
:offset => page_num*page_size)
end
:joins—The :joins parameter to the finder method lets you specify a list of additional tables to be joined to the default table.
:select—The :select parameter takes a string which will appear in the place of the * in the select statement.
:readonly—If :readonly is set to true,Active Record objects returned by find cannot be stored back in to database.If you use the :joins or :select options,objects will automatically be marked :readonly.
:form—The :form option lets you override the table name inserted into the select clause.
:group—The :group option adds a group by clause to the SQL generated by find.
:lock—The :lock option takes either a string or the constrant true.
l find_by_sql
The method find_by_sql lets your application take full control.
l Column Statistics
average(:column_name)
maximum(:column_name)
minimum(:column_name)
sum(:column_name)
count
All the functions take a hash of options,very similar to the hash that can be passed to find.
:conditions
:joins
:limit
:order
:having
:select
:distinct(for count only)
l Dynamic Finders
If you invoke a model’s class method where the method name starts find_by_ or find_all_by_,Active Record converts it to a finder,using the rest of the method’s name to determine the column to be checked. find_by_XXX is converted to find(:first,:conditions=>XXX…).Similary,find_all_by_XXX is converted into matching find(:all,…) calls.
find_by_name_and_password(name,pw)
(3) Updating Existing Rows
update_attribute(Object method) can be called by an object which exists in database.
update(Class method) need pass the id into this method
update_all(Class method) update all rows
(4) Deleting Rows
delete—The delete method takes a single id or an array of ids and deletes the corresponding row(s) in the underlying table.
delete_all—The delete_all method deletes rows matching a given condition(or all rows if no condition is specified).
destroy
destroy_all
7. Composing Data with Aggregations
You define a class to hold the data,and you add a declaration to the model class telling it to map the database column(s) to and from objects of the dataholder class.
composed_of :attr_name, :class_name => SomeClass, :mapping => mapping
