Rails 3中的Active Record的查询变化

最新推荐文章于 2020-01-05 13:13:42 发布

horace_lee

最新推荐文章于 2020-01-05 13:13:42 发布

阅读量214

点赞数

分类专栏： RubyOnRails 文章标签： Rails Ruby ActiveRecord SQL XML

本文链接：https://blog.csdn.net/horace_lee/article/details/83559333

版权

RubyOnRails 专栏收录该内容

293 篇文章 0 订阅

订阅专栏

202: Active Record Queries in Rails 3
译者：夜鸣猪（[url]http://hlee.rubyeye.com/[/url]）校对：哇牛

在上两集的Railscast里我们演示了如何配置Rails 3的配置环境和创建新的Rails 3应用程序。在这一集里我们将开始演示Rails 3的一些新的功能，这里从ActiveRecord的新检索接口开始。Pratik Naik[url=http://m.onkey.org/2010/1/22/active-record-query-interface]有篇blog[/url]文章是关于这个主题的很值得阅读。

[b][size=large]基本的演示例子[/size][/b]

首先，我们使用一个基本的例子对照演示。旧的ActiveRecord如何调用和转换成新的Rails 3下的ActiveRecord如何实现查询调用。假定我们有两个models，Article和Comment，他们之间有has_many:comments的关系。那么，当我们需要查询最近十条记录时会执行如下语句：

	Article.find(:all, :order => "published_at desc", :limit => 10)

当我们把上面的语句转换能Rails 3时，最基本的原则是把查询中的哈希参数替换成对应的方法，以上语句转换如下：

	Article.order("published_at desc").limit(10)

显然新的语法更简洁，可是，往往也不是所有的哈希参数都可以一点不变的转换成对应的方法，例如：

	Article.find(:all, :conditions => ["published_at <= ?", Time.now], :include => :comments)

事实上，这条基本转换的规则（find的hash参数直接转换成同名的方法）只有两个例外，幸运的是上面的例子都包含了他们。上条语句是想要查询所有发布时间早于当前时间的文章和评论，在Rails 3里将会转成如下：

	Article.where("published_at <= ?", Time.now).includes(:comments)

例外就是conditions变成了where，而include变成了复数形式includes。除此之外，所有其他在find中调用的方法，都可以完全和哈希参数同名。
本节最后，让我们看这样一个小例子，查询最近发表的一篇文章：

	Article.find(:first, :order => "published_at desc")

在Rails 3中我们可以转换如下：

	Article.order("published_at desc").first()

值得说明的是，我们要把first放到最后，而且，鉴于我们是降序查询，那么，写成如下也可以：

	Article.order("published_at").last()

这样写的执行效率和上面是一样的，不过，看起来更简洁。
在Rails 3.0里我们可以同时使用上面的两种查询语法。从3.1开始老的查询语法开始作废，到3.2老的查询语法将被完全移除。所以，为了将来考虑早点把老的语法替换掉是值得的。
或者，大家会怀疑为什么要破坏向下兼容的进行这样的语法兼容性修改。进行这样的语法升级的目的在于下面我们将要解释的Lazy Loading。
[b][size=large]Lazy Loading[/size][/b]

为了演示Lazy loading我们将使用Rails的控制台，查询所有的文章得到数组对象，如下：

ruby-1.9.1-p378 > Article.all => [#<Article id: 1, name: "It's Ancient", published_at: nil, hidden: false, 
created_at: "2010-02-22 20:35:42", updated_at: "2010-02-22 20:35:42">, 
#<Article id: 2, name: "Can't See Me", published_at: nil, hidden: false, 
created_at: "2010-02-22 20:37:03", updated_at: "2010-02-22 20:37:03">, 
#<Article id: 3, name: "To the Future!", published_at: nil, hidden: false, 
created_at: "2010-02-22 20:38:17", updated_at: "2010-02-22 20:38:17">]

如果，我们希望把得到的文章按照文章名字进行排序，可以使用如下方法：

ruby-1.9.1-p378 > articles = Article.order("name")
 => #<ActiveRecord::Relation:0x00000101669b90 @table=#<Arel::Table:0x000001023e9af8 
@name="articles", @options={:engine=>#<Arel::Sql::Engine:0x000001023a15c8 @ar=ActiveRecord::Base,
@adapter_name="SQLite">}, @engine=#<Arel::Sql::Engine:0x000001023a15c8 @ar=ActiveRecord::Base,
@adapter_name="SQLite">, …

这时我们会发现查询返回值不是Article的数组对象，而是一个ActiveRecord::Relation的对象。这个对象保存了我们希望进行的查询条件信息，但是数据库并没有实际执行这个查询操作。这就是我们在本篇里所说的Lazy Loading，即除非真正使用这些数据，否则实际的查询就不进行。例如，我们进行迭代或者是调用显示第一条记录，那么，这个数据库的查询就会真正执行，如下：

ruby-1.9.1-p378 > articles.first
 => #<Article id: 2, name: "Can't See Me", published_at: nil, hidden: false, 
created_at: "2010-02-22 20:37:03", updated_at: "2010-02-22 20:37:03">

那么，让我们看看Lazy Loading对于我们的应用有什么作用。如果我们用scaffold来生产Model那么我们应该有会得到一个对应的articles的控制器，并且包含最基本的7个方法。其中，也包括index的方法是用Article.all来立即得到数据：

#/app/controllers/articles_controller.rb
	def index  
	  @articles = Article.all  

	  respond_to do |format|  
	    format.html # index.html.erb  
	    format.xml  { render :xml => @articles }  
	  end  
	end

然而，如果这时我们使用的是Rails 3的语法并且对article使用了任何一种find的参数，例如按照文章名排序。这时Article.order(“name”)就会返回ActiveRecord::Relation的对象并且，实际的数据库查询不会在controller调用的时候执行。而是，在view页面进行迭代输出的时候执行。（译者[url=http://hlee.iteye.com]晓夜[/url]注：这就是Lazy Loading的标准含义，减少触发时的等待时间，也就是降低返回空白页的等待可能。当然，下文还提到了Lazy Loading别的好处。）

#/app/views/articles/index.html.erb
	<% @articles.each do |article| %>  
	  <tr>  
	    <td><%= article.name %></td>  
	    <td><%= article.published_at %></td>  
	    <td><%= article.hidden %></td>  
	    <td><%= link_to 'Show', article %></td>  
	    <td><%= link_to 'Edit', edit_article_path(article) %></td>  
	    <td><%= link_to 'Destroy', article, :confirm => 'Are you sure?', :method => :delete %></td>  
	  </tr>  
	<% end %>

这时我们就会看到按照文章名排序的列表。

[img]http://dl.iteye.com/upload/attachment/209725/e2f552e0-6393-3f2c-82e2-f8d6fb8a7707.png[/img]

Lazy Loading的好处也在于当view开启了fragment caching的时候，这时，数据库因为缓存，有些时候查询就不用实际执行。新的查询语法更容易构建查询条件，例如，我们希望检索只有设置了隐藏属性（hidden==1）的记录，那么，我们可以如下修改index方法：

#/app/controllers/articles_controller.rb
	def index  
	  @articles = Article.order('name')  

	  if params[:hidden]  
	    @articles = @articles.where(:hidden =>(params[:hidden] == "1"))  
	  end  

	  respond_to do |format|  
	    format.html # index.html.erb  
	    format.xml  { render :xml => @articles }  
	  end  
	end

这时，该方法会检查是否有hidden的参数传入，并且根据参数情况显示如下：

[img]http://dl.iteye.com/upload/attachment/209727/1c29a9c0-befe-3ebb-b5ad-7d60eae371a7.png[/img]

同样的情况，如果参数传入为0那么会列出如下：

[img]http://dl.iteye.com/upload/attachment/209729/42effc01-462f-3b11-b432-c00e7a900e7b.png[/img]

也就是说，利用上面的原理，就可以把复杂的查询条件串联起来，并且，这样的查询条件修改[b]的时候，实际的查询并没有在数据库中操作。
[size=large]Named Scopes[/size][/b]

下面我们看看在Rails 3中named scopes的变化。假如，在Article下有两个named scopes，visible用来表示隐藏的文章，published用来表示已经发布的文章。

#/app/models/article.rb
	class Article < ActiveRecord::Base  
	  named_scope :visible, :conditions => ["hidden != ?", true]  
	  named_scope :published, lambda { {:conditions => ["published_at <= ?", Time.zone.now]} }  
	end

上面的语句是Rails 2中定义named scoped的方式，在Rails 3中named scoped的语法稍微有点不同。首先是用scoped代替named scoped，其次，和find的变化相同，不再使用find的哈希参数，而是改用同名的方法，而conditions会变成where如下：

#/app/models/article.rb
	class Article < ActiveRecord::Base  
	  scope :visible, where("hidden != ?", true)  
	  scope :published, lambda { where("published_at <= ?", Time.zone.now) }  
	end

另外一个关于scope的新功能是可以通过scope创建scope，例如，我们希望创建一个叫做recent的scope，表示发布过并且没有隐藏的文章列表，并且文章列表按照发布的降序排列。那么，我们就可以通过使用visible和pulished来实现如下：

	scope :recent, visible.published.order("published_at desc")

如上所示，我们就是通过将两个scopes连起来，并且添加一个排序的方法来创建scope的。而且，我们也可以通过在控制台调试我们的scope，发现当我们调用Article.recent时，会返回一个ActiveRecord::NamedScope::Scope的对象，而这个对象会和ActiveRecord::Relation有相似的功能，即lazy loading不是当即查询。如下：

ruby-1.9.1-p378 > Article.recent
 => #<ActiveRecord::NamedScope::Scope:0x0000010318bd08 @table=#<Arel::Table:0x00000102740ea8 
 @name="articles", @options={:engine=>#<Arel::Sql::Engine:0x00000102651900 @ar=ActiveRecord::Base>}, 
 @engine=#<Arel::Sql::Engine:0x00000102651900 @ar=ActiveRecord::Base>>, …

当我们查询所有时，我们将会看到对应的Article对象返回。（译者[url=http://hlee.iteye.com]晓夜[/url]注：就是说在用的时候返回）

ruby-1.9.1-p378 > Article.recent.all
 => [#<Article id: 1, name: "It's Ancient", published_at: "2010-01-01", 
 hidden: false, created_at: "2010-02-22 20:35:42", updated_at: "2010-02-22 23:00:16">]

[b][size=large]有用的工具[/size][/b]

最后，我们将使用一点有用的工具方法结束本篇的介绍。如果，我们得到了一个类似Relation 或者 Scope的对象（即缓存查询，并没有实际返回数据库查询结果的对象）我们可以通过to_sql来查看对应的查询条件，如下：

ruby-1.9.1-p378 > Article.recent.to_sql
 => "SELECT     \"articles\".* FROM       \"articles\" 
 WHERE     (hidden != 't') AND (published_at <= '2010-02-22 22:47:12.023289') 
 ORDER BY  published_at desc"

上面的查询将返回没有隐藏的最近发布的文章。这就是Rails 3中ActiveRecord查询部分的改进。同时Rails 3中对于controller部分也有一些语法变化，使得语法更简练强大。学习使用新的语法，你会发现这是值得的。