这更像是“为什么会这样做”这个问题，而不是“我不知道怎么做”这个问题......
因此，关于提取您知道将要使用的相关记录的福音是使用: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 认识到性能问题，除非在某些情况下不加入？
答案 0 :(得分：170)
似乎使用Rails 2.1更改了:include功能。 Rails用于在所有情况下进行连接，但出于性能原因，在某些情况下将其更改为使用多个查询。 Fabio Akita的This blog post提供了有关变更的一些很好的信息（参见标题为“优化的预先加载”的部分）。
答案 1 :(得分：87)
.joins将加入表格并返回选定的字段。如果你在连接查询结果上调用关联，它将再次触发数据库查询
:includes将急切加载包含的关联并将其添加到内存中。 :includes加载所有包含的表属性。如果您在包含查询结果上调用关联，则不会触发任何查询
答案 2 :(得分：69)
join和include之间的区别在于，使用include语句会生成一个更大的SQL查询，将来自其他表的所有属性加载到内存中。
例如，如果您有一个充满评论的表格，并使用：joins =＆gt;用户可以提取所有用户信息以进行排序等，它可以正常运行并且花费的时间少于：include，但是您要显示注释以及用户名，电子邮件等。要使用以下内容获取信息：join ，它必须为它提取的每个用户分别进行SQL查询，而如果你使用：include这个信息可以使用了。
很好的例子：
答案 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} 没有查询会触发