Rails:include vs.:join

时间:2009-07-30 19:00:52

标签: ruby-on-rails ruby database join rails-activerecord

这更像是“为什么会这样做”这个问题,而不是“我不知道怎么做”这个问题......

因此,关于提取您知道将要使用的相关记录的福音是使用:include,因为您将获得加入并避免一大堆额外查询:

Post.all(:include => :comments)

然而,当你查看日志时,没有发生加入:

Post Load (3.7ms)   SELECT * FROM "posts"
Comment Load (0.2ms)   SELECT "comments.*" FROM "comments" 
                       WHERE ("comments".post_id IN (1,2,3,4)) 
                       ORDER BY created_at asc) 

采用快捷方式,因为它会立即提取所有注释,但它仍然不是连接(这是所有文档似乎都说的)。我可以获得加入的唯一方法是使用:joins代替:include

Post.all(:joins => :comments)

日志显示:

Post Load (6.0ms)  SELECT "posts".* FROM "posts" 
                   INNER JOIN "comments" ON "posts".id = "comments".post_id

我错过了什么吗?我有一个有六个关联的应用程序,在一个屏幕上我显示所有这些数据。似乎最好有一个加入查询而不是6个人。我知道在性能方面,进行连接而不是单个查询并不总是更好(事实上,如果你花费时间,看起来上面的两个单独的查询比连接更快),但是在所有文档之后我一直在阅读,我很惊讶地发现:include没有像宣传的那样工作。

也许Rails 认识到性能问题,除非在某些情况下不加入?

8 个答案:

答案 0 :(得分:170)

似乎使用Rails 2.1更改了:include功能。 Rails用于在所有情况下进行连接,但出于性能原因,在某些情况下将其更改为使用多个查询。 Fabio Akita的This blog post提供了有关变更的一些很好的信息(参见标题为“优化的预先加载”的部分)。

答案 1 :(得分:87)

.joins将加入表格并返回选定的字段。如果你在连接查询结果上调用关联,它将再次触发数据库查询

:includes将急切加载包含的关联并将其添加到内存中。 :includes加载所有包含的表属性。如果您在包含查询结果上调用关联,则不会触发任何查询

答案 2 :(得分:69)

join和include之间的区别在于,使用include语句会生成一个更大的SQL查询,将来自其他表的所有属性加载到内存中。

例如,如果您有一个充满评论的表格,并使用:joins =>用户可以提取所有用户信息以进行排序等,它可以正常运行并且花费的时间少于:include,但是您要显示注释以及用户名,电子邮件等。要使用以下内容获取信息:join ,它必须为它提取的每个用户分别进行SQL查询,而如果你使用:include这个信息可以使用了。

很好的例子:

http://railscasts.com/episodes/181-include-vs-joins

答案 3 :(得分:52)

除了性能方面的考虑外,还存在功能差异。 当您加入评论时,您要求发布具有评论的帖子 - 默认情况下为内部联接。 当您包含评论时,您要求所有帖子 - 外部联接。

答案 4 :(得分:49)

我最近正在阅读有关rails中:joins:includes之间差异的更多信息。这是我理解的解释(用例子:))

考虑这种情况:

  • 用户has_many评论和评论belongs_to用户。

  • User模型具有以下属性:Name(字符串),Age(整数)。 Comment模型具有以下属性:Content,user_id。对于注释,user_id可以为null。

连接:

:join在两个表之间执行内部联接。因此

Comment.joins(:user)

#=> <ActiveRecord::Relation [#<Comment id: 1, content: "Hi I am Aaditi.This is my first   comment!", user_id: 1, created_at: "2014-11-12 18:29:24", updated_at: "2014-11-12 18:29:24">, 
     #<Comment id: 2, content: "Hi I am Ankita.This is my first comment!", user_id: 2, created_at: "2014-11-12 18:29:29", updated_at: "2014-11-12 18:29:29">,    
     #<Comment id: 3, content: "Hi I am John.This is my first comment!", user_id: 3, created_at: "2014-11-12 18:30:25", updated_at: "2014-11-12 18:30:25">]>

将获取所有记录,其中user_id(评论表)等于user.id(用户表)。因此,如果你这样做

Comment.joins(:user).where("comments.user_id is null")

#=> <ActiveRecord::Relation []>

您将获得一个空数组,如图所示。

此外,连接不会将连接的表加载到内存中。因此,如果你这样做

comment_1 = Comment.joins(:user).first

comment_1.user.age
#=>←[1m←[36mUser Load (0.0ms)←[0m  ←[1mSELECT "users".* FROM "users" WHERE "users"."id" = ? ORDER BY "users"."id" ASC LIMIT 1←[0m  [["id", 1]]
#=> 24

如您所见,comment_1.user.age将在后台再次触发数据库查询以获取结果

包括:

:includes在两个表之间执行左外连接。因此

Comment.includes(:user)

#=><ActiveRecord::Relation [#<Comment id: 1, content: "Hi I am Aaditi.This is my first comment!", user_id: 1, created_at: "2014-11-12 18:29:24", updated_at: "2014-11-12 18:29:24">,
   #<Comment id: 2, content: "Hi I am Ankita.This is my first comment!", user_id: 2, created_at: "2014-11-12 18:29:29", updated_at: "2014-11-12 18:29:29">,
   #<Comment id: 3, content: "Hi I am John.This is my first comment!", user_id: 3, created_at: "2014-11-12 18:30:25", updated_at: "2014-11-12 18:30:25">,    
   #<Comment id: 4, content: "Hi This is an anonymous comment!", user_id: nil, created_at: "2014-11-12 18:31:02", updated_at: "2014-11-12 18:31:02">]>

将导致一个包含评论表中所有记录的连接表。因此,如果你这样做

Comment.includes(:user).where("comment.user_id is null")
#=> #<ActiveRecord::Relation [#<Comment id: 4, content: "Hi This is an anonymous comment!", user_id: nil, created_at: "2014-11-12 18:31:02", updated_at: "2014-11-12 18:31:02">]>

它将获取comments.user_id为零的记录,如图所示。

此外,还包括加载内存中的两个表。因此,如果你这样做

comment_1 = Comment.includes(:user).first

comment_1.user.age
#=> 24

您可以注意到,comment_1.user.age只是从内存加载结果而不在后台触发数据库查询。

答案 5 :(得分:9)

TL;博士

我用两种方式对比它们:

加入 - 用于条件选择记录。

包括 - 在结果集的每个成员上使用关联时。

更长的版本

联接意味着过滤来自数据库的结果集。您可以使用它来对表进行设置操作。可以把它想象成执行集合论的where子句。

Post.joins(:comments)

相同

Post.where('id in (select post_id from comments)')

除非有多个评论,否则您将通过联接返回重复的帖子。但每篇文章都将是一篇有评论的帖子。您可以使用distinct进行更正:

Post.joins(:comments).count
=> 10
Post.joins(:comments).distinct.count
=> 2

在契约中,includes方法只会确保在引用关系时没有其他数据库查询(这样我们就不会进行n + 1次查询)

Post.includes(:comments).count
=> 4 # includes posts without comments so the count might be higher.

道德是,当你想要进行条件集操作时使用joins,当你要在集合的每个成员上使用关系时使用includes

答案 6 :(得分:4)

.joins用作数据库连接,它连接两个或多个表并从后端(数据库)获取所选数据。

。包括作为数据库左连接的工作。它加载了左侧的所有记录,没有右侧模型的相关性。它用于急切加载,因为它加载内存中的所有关联对象。如果我们在包含查询结果上调用关联,那么它不会在数据库上触发查询,它只是从内存中返回数据,因为它已经在内存中加载了数据。

答案 7 :(得分:0)

'join'刚刚用于连接表,当你在连接上调用关联时,它会再次触发查询(这意味着许多查询将触发)

lets suppose you have tow model, User and Organisation
User has_many organisations
suppose you have 10 organisation for a user 
@records= User.joins(:organisations).where("organisations.user_id = 1")
QUERY will be 
 select * from users INNER JOIN organisations ON organisations.user_id = users.id where organisations.user_id = 1

it will return all records of organisation related to user
and @records.map{|u|u.organisation.name}
it run QUERY like 
select * from organisations where organisations.id = x then time(hwo many organisation you have)
在这种情况下,

SQL总数为11

但是 'includes'将急切加载包含的关联并将它们添加到内存中(在首次加载时加载所有关联)而不再重新启动查询

当你获得包含类似的记录时 @ records = User.includes(:organizations).where(“organisations.user_id = 1”) 那么查询将是

select * from users INNER JOIN organisations ON organisations.user_id = users.id where organisations.user_id = 1
and 


 select * from organisations where organisations.id IN(IDS of organisation(1, to 10)) if 10 organisation
and when you run this 

@ records.map {| U | u.organisation.name}     没有查询会触发