想要在Rails中查找没有关联记录的记录

考虑一个简单的关联...

class Person
   has_many :friends
end

class Friend
   belongs_to :person
end

在Arel和/或meta_where中，让所有没有朋友的人最干净的方法是什么？

然后has_many：through版本呢？

class Person
   has_many :contacts
   has_many :friends, :through => :contacts, :uniq => true
end

class Friend
   has_many :contacts
   has_many :people, :through => :contacts, :uniq => true
end

class Contact
   belongs_to :friend
   belongs_to :person
end

我真的不想使用counter_cache-从我阅读的内容来看，它不适用于has_many：through

我不想拉所有的person.friends记录并在Ruby中遍历它们-我想要一个可以与meta_search gem一起使用的查询/范围

我不在乎查询的性能成本

与实际SQL距离越远越好...

这仍然非常接近SQL，但是在第一种情况下，应该使每个人都没有朋友：

Person.where('id NOT IN (SELECT DISTINCT(person_id) FROM friends)')

更好：

Person.includes(:friends).where( :friends => { :person_id => nil } )

对于hmt来说，基本上是同一件事，您依赖一个事实，即没有朋友的人也没有联系：

Person.includes(:contacts).where( :contacts => { :person_id => nil } )

更新资料

has_one在评论中有一个关于的问题，因此只需更新即可。这里的技巧是includes()期望关联的名称，但是where期望表的名称。对于has_one关联，关联通常将以单数表示，以便进行更改，但该where()部分保持原样。因此，如果Person只有，has_one :contact那么您的陈述将是：

Person.includes(:contact).where( :contacts => { :person_id => nil } )

更新2

有人问反面，没有人的朋友。正如我在下面评论的那样，这实际上使我意识到，最后一个字段（在上方:person_id）实际上不必与您要返回的模型相关，它只必须是联接表中的一个字段。他们都将成为所有人nil。这导致上述解决方案更简单：

Person.includes(:contacts).where( :contacts => { :id => nil } )

然后切换此设置以返回没有人的朋友变得更加简单，您只需更改前面的类即可：

Friend.includes(:contacts).where( :contacts => { :id => nil } )

更新3-Rails 5

感谢@Anson提供出色的Rails 5解决方案（在下面为他的答案提供一些+1），您left_outer_joins可以避免加载关联：

Person.left_outer_joins(:contacts).where( contacts: { id: nil } )

我将其包含在此处，以便人们找到它，但是他值得为此加+1。很棒的补充！

更新4-Rails 6.1

感谢Tim Park指出，在即将到来的6.1中，您可以执行以下操作：

Person.where.missing(:contacts)

多亏了他的帖子，他也链接到了。

smathy对Rails 3的回答很好。

对于Rails 5，可以使用left_outer_joins避免加载关联。

Person.left_outer_joins(:contacts).where( contacts: { id: nil } )

查看api文档。在请求请求＃12071中引入了它。

没有朋友的人

Person.includes(:friends).where("friends.person_id IS NULL")

或者至少有一个朋友

Person.includes(:friends).where("friends.person_id IS NOT NULL")

您可以通过以下方式在Arel上设置作用域 Friend

class Friend
  belongs_to :person

  scope :to_somebody, ->{ where arel_table[:person_id].not_eq(nil) }
  scope :to_nobody,   ->{ where arel_table[:person_id].eq(nil) }
end

然后，至少拥有一个朋友的人：

Person.includes(:friends).merge(Friend.to_somebody)

没有朋友的人：

Person.includes(:friends).merge(Friend.to_nobody)

dmarkow和Unixmonkey的答案都给了我我所需要的-谢谢！

我在真实的应用程序中尝试了两种方法，并获得了时间安排-这是两个作用域：

class Person
  has_many :contacts
  has_many :friends, :through => :contacts, :uniq => true
  scope :without_friends_v1, -> { where("(select count(*) from contacts where person_id=people.id) = 0") }
  scope :without_friends_v2, -> { where("id NOT IN (SELECT DISTINCT(person_id) FROM contacts)") }
end

使用真实的应用程序运行此程序-带有约700条“人”记录的小桌子-平均5次运行

Unixmonkey的方法（:without_friends_v1）813ms /查询

dmarkow的方法（:without_friends_v2）891ms /查询（慢10％）

但是后来我想到，我不需要打DISTINCT()...我要查找Person带有NO的记录的电话Contacts-因此它们只需要NOT IN作为联系人列表person_ids。所以我尝试了这个范围：

  scope :without_friends_v3, -> { where("id NOT IN (SELECT person_id FROM contacts)") }

结果相同，但平均每次通话425毫秒-几乎是一半的时间...

现在您可能需要DISTINCT在其他类似查询中使用-但就我而言，这似乎工作正常。

谢谢你的帮助

不幸的是，您可能正在寻找一种涉及SQL的解决方案，但是您可以在范围内进行设置，然后仅使用该范围：

class Person
  has_many :contacts
  has_many :friends, :through => :contacts, :uniq => true
  scope :without_friends, where("(select count(*) from contacts where person_id=people.id) = 0")
end

然后，只要获得它们，就Person.without_friends可以将其与其他Arel方法链接起来：Person.without_friends.order("name").limit(10)

与NOT NOTISTS相关的子查询应该很快，尤其是当行数和子记录与父记录的比率增加时。

scope :without_friends, where("NOT EXISTS (SELECT null FROM contacts where contacts.person_id = people.id)")

另外，例如，要由一位朋友过滤掉：

Friend.where.not(id: other_friend.friends.pluck(:id))