Rails :include 与 :joins

Question

这更多的是一个“为什么事情会这样工作”的问题，而不是一个“我不知道如何做到这一点”的问题......

因此，提取您知道将要使用的关联记录的福音是使用 :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

我错过了什么吗？ 我有一个包含六个关联的应用程序，我在一个屏幕上显示所有关联的数据。 似乎使用 1 个连接查询比 6 个个体更好。 我知道从性能角度来看，进行联接并不总是比单独查询更好（事实上，如果您按照花费的时间计算，看起来上面的两个单独查询比联接更快），但毕竟文档我一直在阅读，我很惊讶地发现 :include 没有像广告中那样工作。

也许 Rails 意识到了性能问题并且除了某些情况外不会加入？

Answer 1

Rails 2.1 似乎改变了 :include 功能。 Rails 过去在所有情况下都会进行连接，但出于性能原因，它被更改为在某些情况下使用多个查询。 这篇博文Fabio Akita 的 提供了有关此更改的一些很好的信息（请参阅标题为“优化的预加载”的部分）。

Answer 2

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

:includes 将立即加载包含的关联并将它们添加到内存中。 :includes 加载所有包含的表属性。 如果您在包含查询结果上调用关联，它将不会触发任何查询

Answer 3

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

例如，如果您有一个充满注释的表，并且您使用 :joins =>; 用户提取所有用户信息以进行排序等，它会工作得很好，并且比 :include 花费的时间更少，但假设您想要显示评论以及用户名、电子邮件等。要使用 :joins 获取信息，它必须为它获取的每个用户进行单独的 SQL 查询，而如果您使用 :include ，则此信息可供使用。

很好的例子：

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

Answer 4

我最近阅读了有关 Rails 中 :joins 和 :includes 之间差异的更多内容。 以下是我的理解的解释（带有示例:)）

考虑这种情况：

• 一个用户有很多评论，并且一个评论属于一个用户。

• 用户模型具有以下属性：Name（字符串）、Age（整数）。 Comment模型有以下属性：Content、user_id。 对于评论，user_id 可以为 null。

联接：

：联接在两个表之间执行内联接。 因此，

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
#=> User Load (0.0ms)  SELECT "users".* FROM "users" WHERE "users"."id" = ? ORDER BY "users"."id" ASC LIMIT 1 [["id", 1]]
#=> 24

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

Includes:

:includes 执行 left两个表之间的外部联接。 因此，

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">]>

将产生一个包含 comments 表中所有记录的连接表。因此，如果您这样做，

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 为 nil 的记录，如图所示。

此外还包括将两个表加载到内存中。 因此，如果您

comment_1 = Comment.includes(:user).first

comment_1.user.age
#=> 24

这样做，您可以注意到 comment_1.user.age 只是从内存中加载结果，而无需在后台触发数据库查询。

Answer 5

除了性能考虑之外，还存在功能差异。
当您加入评论时，您是在请求有评论的帖子 - 默认情况下是内部联接。
当您添加评论时，您会要求所有帖子 - 外部联接。

Answer 6

tl;dr

我通过两种方式对比它们：

连接 - 用于有条件地选择记录。

包含 - 对结果集的每个成员使用关联时。

较长版本

连接旨在过滤来自数据库的结果集。 您可以使用它在表上执行集合操作。 将其视为执行集合论的 where 子句。

Post.joins(:comments)

相同

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

，除非有多个评论将通过连接返回重复的帖子。 但每个帖子都会有评论。 您可以使用不同的方法来纠正此问题：

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。

Answer 7

.joins 用作数据库连接，它连接两个或多个表并从后端（数据库）获取选定的数据。

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

Answer 8

“joins”仅用于连接表，当您在连接上调用关联时，它将再次触发查询（这意味着将触发许多查询）

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("organizations.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.organization.name}
不会触发任何查询