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

例如，如果您有一个充满评论的表，并且您使用a:joins => users来拉入所有用户信息以进行排序，等等，它将工作得很好，并且比:include花费的时间要少，但是您想要显示评论以及用户名称、电子邮件等。要使用:joins获取信息，它必须为它获取的每个用户进行单独的SQL查询，而如果使用:include，则此信息已准备好使用。

很好的例子:

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

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

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

我最近阅读了更多关于rails中:joins和:includes的区别。以下是我的理解(有例子:))

考虑一下这个场景:

一个User has_many comments和一个comment belongs_to一个User。 User模型有以下属性:名称(字符串)，年龄(整数)。Comment模型有以下属性:Content, user_id。对于注释，user_id可以为空。

连接:

:joins执行两个表之间的内部连接。因此

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 (users表)。因此如果你这样做

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将在后台再次触发数据库查询以获得结果

包括:

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

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

它将获取注释所在的记录。如所示，User_id为nil。

而且包括在内存中加载两个表。因此如果你这样做

comment_1 = Comment.includes(:user).first

comment_1.user.age
#=> 24

如你所见，comment_1.user。Age只需从内存中加载结果，而无需在后台触发数据库查询。

看来:include功能在Rails 2.1中有所改变。Rails过去在所有情况下都执行连接，但出于性能原因，在某些情况下更改为使用多个查询。Fabio Akita的这篇博客文章有一些关于这个变化的很好的信息(参见标题为“优化的快速加载”部分)。

'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(组织)。(“组织。User_id = 1") 那么query将是

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 

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

博士tl;

我从两个方面对它们进行对比:

joins—用于有条件地选择记录。

includes—在结果集的每个成员上使用关联时。

完整版

join用于过滤来自数据库的结果集。你可以用它在表上做set操作。把它看作是执行集合理论的where子句。

Post.joins(评论)

和

职位。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.

寓意是，当您想要执行条件集操作时使用连接，当您要在集合的每个成员上使用关系时使用包含。