Create & Save
创建 & 保存
- order = Order.new
- order.name = "virusswb"
- order.email = "asdf@exmaple.com"
- order.save
调用save方法之后就可以保存到数据库了。
还可以用block来创建并保存。
- Order.new do |order|
- order.name = "virusswb"
- order.email = "asdf@example.com"
- order.save
- end
还可以使用hash的方式创建并保存。
- order = Order.new(
- :name => "virus",
- :email => "adf@example.com"
- )
- order.save
默认id主键不用赋值，是integer的自增列。
上面的方法都需要调用save方法才能保存到数据库，用create方法可以合二为一，创建同时保存到数据库。
- order = Order.create(
- :name => "virus",
- :email => "adf@exmaple.com"
- )
还可以一次保存多个，只要给create传递一个数组就可以实现。
- orders = Order.create(
- [{ :name => "virus1",
- :email => "111@123.com"
- },
- { :name => "swb2",
- :email => "222@123.com"
- }]
- )
返回也是一个数组。
从form放入参数中直接创建一个model对象。
- @order = Order.new(params[:order])
Order.find(1)可以用来获取id=1的model，但是如果数据表中不存在id=1的model，就会抛出RecordNotFound异常。
如果使用Order.where(:id => 1).first，是告诉数据库“我需要id=1的记录”，如果不存在这样的记录，不会抛出异常，返回的是nil。
Reading Existing Rows
读取
- an_order = Order.find(27)
返回一条记录，如果没有，会抛出RecordNotFound异常。
- product_list = params[:product_ids]
- total = Product.find(product_list).sum(&:price)
给find传入array，可以实现多条记录的查询，但是如果其中一个id不存在的话，还是会抛出RecordNotFound异常 。
Dynamic Finders
动态查询
有时候我们会针对model的一列进行查询，在rails中不用写sql就可以实现。
- order = Order.find_by_name("virus")
- orders = Order.find_all_by_name("virus")
- orders = Order.find_all_by_email(params['email'])
- order = Order.find_by_name("virus")
和
- order = Order.where(:name => "virus").first
效果是一样的。
还有find_all_by_xxx和find_last_by_xxx这样的查询。
如果在find_by_方法后面加上一个!，就会在找不到记录的情况下抛出RecordNotFound异常。
- order = Order.find_by_name!("virus")
还可以多列查询。
- order = Order.find_by_name_and_password(name,pw)
和
- order = Order.where(:name => name, :password => pw).first
是一样的效果。
有些情况下，你想要确保有model，如果在数据库中不存在，就创建一个，动态的finders就可以实现这个需求。find_or_initialize_by_或者find_or_create_by_可以实现没有满足条件的记录，就返回nil，就会创建或者直接保存记录。
- cart = Cart.find_or_initialize_by_user_id(user.id)
- cart.items << new_item
- cart.save
SQL and ActiveRecord
在AcriveRecord中使用SQL
用model的where方法可以实现sql语句的where子句。
- pos = Order.where("name = 'virus' and emal = 'sf@123.com'")
接收外部传过来的name的值。
- name = params[:name]
- pos = Order.where("name = '#{name}' and email = '123@123.com'")
上面拼接sql语句的方式，会受到sql注入攻击。
安全的方式是让ActiveRecord来处理，参数化。
- name = params[:name]
- pos = Order.where(["name = ? and email ='sd'", name])
- name = params[:name]
- email = params[:email]
- pos = Order.where("name = :name and email = :email",
- { :name => name, :email => email})
因为params已经是hash了，可以简洁一些。
- pos = Order.where("name = :name and email = :email",
- params[:order])
还可以更简洁一些。
- pos = Order.where(params[:order])
要小心上面的写法，它使用了所有的参数，通过下面的写法，你可以指定使用哪些参数。
- pos = Order.where( :name => params[:name], :email => params[:email])
Using like Clauses
使用like子句
- User.where("name like ?", params[:name] + "%")
Subsetting the Recods Returned
返回部分数据
order排序
- orders = Order.where(:name => params[:name])
- .order("name, email desc")
limit限制返回的条数
- orders = Order.where(:name => params[:name])
- .order("name, email desc")
- .limit(10)
offset跳过行
offset相当于mysql中的skip。
- def Order.find_on_page(page_num, page_size)
- orders = Order.where(:name => params[:name])
- .order("name, email desc")
- .limit(page_size)
- .offset(page_num*page_size)
- end
select选择列
默认选择所有的列，可以通过select来查询需要的列。
- orders = Order.where(:name => params[:name])
- .order("name, email desc")
- .select("name, email")
joins连接
- LineItem.select('li.quantity')
- .where("pr.title = 'programming in ruby'")
- .joins("as li inner join products pr on li.product_id=pr.id")
readonly只读
使用readonly方法获取的记录，不能再保存回数据库。
如果使用joins或者是select方法，返回的对象自动标记为readonly。
group分组
会产生group by子句。
- summary = LineItem.select(select = > "sku, sum(amount) as amount")
- .group("sku")
lock锁
lock方法的参数是一个字符串，告诉数据库使用指定类型的锁。
在mysql中共享锁返回最新的数据行，并且确保没有人可以在锁期间修改这条记录。
- Account.transaction do
- ac = Account.where(:id => id).lock("LOCK IN SHARE MODE").first
- ac.balance -= amount if ac.balance > amount
- ac.save
- end
Getting Column Statistics
聚合统计
- average = Order.average(:amount)
- max = Order.maximun(:amount)
- min = Order.minimun(:amount)
- total = Order.sum(:amount)
- number = Order.count
上面的这些聚合函数都是数据库无关的。
也可以联合其他方法一起使用。
- Order.where("amount > 20").minimun(:amount)
通常情况，这些聚合函数返回的是一个值。如果包含group方法，返回的就是每一组的聚合结果，也就是返回一系列值。
- result = Order.maximun(:amount).group(:state)
- puts result #=> [["TX", 123456], ["NX", 3456]]
Scopes
范围查询
- class Order < ActiveRecord::Base
- scope :last_n_days, lambda do |days|
- where("updated < ?", days)
- end
- end
- orders= Order.last_n_days(7)
- class Order < ActiveRecord::Base
- scope :checks, where(:pay_type => :check)
- end
- orders = Order.checks.last_n_days(7)
- in_house = Order.where('email like "%@pragprog.com"')
- in_house.checks.last_n_days(7)
Writing Our Own SQL
执行查询SQL
- orders = LineItem.find_by_sql("select line_items.* from line_items, orders where order_id = orders.id and orders.name = 'virus'"
- orders = Order.find_by_sql("select name, pay_type from orders")
- first = orders[0]
- p first.attributes #=>{"name" => "shi", "pay_type" => "check"}
- p first.attribute_names #=>["name", "pay_type"]
- p first.attribute_present?("address") #=>false
Reloading Data
重新加载数据
我们的应用会被多个用户访问，有的时候，之前取出来的数据已经被其他用户修改，这时候你又需要最新的数据，可以调用model的reload方法来实现。
- loop do
- puts "Price = #{stock.price}"
- sleep 60
- stock.reload
- end
Updating Existing Rows
更新数据
调用model的save方法就可以实现更新，通过id来匹配数据，如果存在数据，就是更新，如果不存在数据，就插入一条。
- order = Order.find(10)
- order.name = "swb"
- order.save
- orders = Order.find_by_sql("select id, name, email from orders where id = 12")
- first = orders[0]
- first.name = "newname"
- first.save
- order = Order.find(12)
- order.update_attribute(:name, "newname")
- order = Order.find(12)
- order.update_attributes(:name => "newname", :email => "newmail")
- def save_after_edit
- order = Order.find(params[:id])
- if order.update_attributes(params[:order])
- redirect_to :action => :index
- else
- render :action => :edit
- end
- end
- order = Order.update(12, :name => "newname", :email => "newmail")
- result = Order.update_all("price = 1.1*price", "title like '%java%'")
save, save!, create, create!
- save，保存成功返回true，否则返回nil。
- save!，保存成功返回true，否则抛出异常。
- create，无论保存成功与否，都会返回model对象。你需要通过检查validation errros来确定保存是否成功。
- create!，保存成功返回true，否则抛出异常。
- if order.save
- # all ok
- else
- # validation fail
- end
- begin
- order.save!
- rescue RecordInvalid => error
- # validation fail
- end
Deleting Rows
删除数据
类级别的delete方法
- Order.delete(10)
- User.delete([2,3,4,5])
- Product.delete_all(["price > ?", @expensize_price])
delete方法通过id或者id集合删除数据，delete_all通过条件删除数据，返回值是受影响的行数，没有符合条件的数据也不会抛出异常。
对象级别的destroy方法
- order = Order.find(10)
- order.destroy
调用对象的destroy方法之后，就会锁定对象，防止对他进行修改。
Order.destroy_all(["price > ?", @expensize_price])
delete方法会忽略验证功能，destroy方法会确保它们被执行。通常来说，如果你想要确保你的数据符合业务规则，最好使用destroy方法。
本文转自 virusswb 51CTO博客，原文链接：http://blog.51cto.com/virusswb/1016292，如需转载请自行联系原作者
