Vous voulez trouver des enregistrements sans enregistrements associés dans Rails

Prenons une simple association ...

class Person
   has_many :friends
end

class Friend
   belongs_to :person
end

Quelle est la manière la plus propre d'obtenir toutes les personnes qui n'ont AUCUN ami dans ARel et / ou meta_where?

Et puis qu'en est-il d'un has_many: through version

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

Je ne veux vraiment pas utiliser counter_cache - et d'après ce que j'ai lu, cela ne fonctionne pas avec has_many: through

Je ne veux pas extraire tous les enregistrements person.friends et les parcourir en boucle dans Ruby - je veux avoir une requête / portée que je peux utiliser avec le gem meta_search

Le coût des performances des requêtes ne me dérange pas

Et plus vous vous éloignez du SQL réel, mieux c'est ...

C'est encore assez proche de SQL, mais cela devrait amener tout le monde sans amis dans le premier cas:

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

Mieux:

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

Pour le hmt, c'est fondamentalement la même chose, vous comptez sur le fait qu'une personne sans amis n'aura pas non plus de contacts:

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

Mettre à jour

Vous avez une question à propos has_onedes commentaires, donc juste une mise à jour. L'astuce ici est qu'il includes()attend le nom de l'association mais whereattend le nom de la table. Pour un, has_onel'association sera généralement exprimée au singulier, de sorte que cela change, mais la where()partie reste telle qu'elle est. Donc, si Personseulement has_one :contactalors votre déclaration serait:

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

Mise à jour 2

Quelqu'un a demandé l'inverse, des amis sans personne. Comme je l'ai commenté ci-dessous, cela m'a fait réaliser que le dernier champ (ci-dessus: le :person_id) n'a pas à être lié au modèle que vous renvoyez, il doit simplement s'agir d'un champ dans la table de jointure. Ils vont tous l'être, nildonc ça peut être n'importe lequel d'entre eux. Cela conduit à une solution plus simple à ce qui précède:

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

Et puis changer cela pour renvoyer les amis sans personne devient encore plus simple, vous ne changez que la classe à l'avant:

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

Mise à jour 3 - Rails 5

Merci à @Anson pour l'excellente solution Rails 5 (donnez-lui quelques + 1 pour sa réponse ci-dessous), vous pouvez utiliser left_outer_joinspour éviter de charger l'association:

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

Je l'ai inclus ici pour que les gens le trouvent, mais il mérite les + 1 pour cela. Excellent ajout!

Mise à jour 4 - Rails 6.1

Merci à Tim Park d' avoir souligné que dans la prochaine version 6.1, vous pouvez le faire:

Person.where.missing(:contacts)

Merci aussi au post auquel il a lié.

smathy a une bonne réponse Rails 3.

Pour Rails 5 , vous pouvez utiliser left_outer_joinspour éviter de charger l'association.

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

Consultez la documentation de l' API . Il a été introduit dans la demande d'extraction # 12071 .

Les personnes qui n'ont pas d'amis

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

Ou qui ont au moins un ami

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

Vous pouvez le faire avec Arel en configurant des étendues sur 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

Et puis, les personnes qui ont au moins un ami:

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

Les sans amis:

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

Les réponses de dmarkow et d'Unixmonkey m'apportent ce dont j'ai besoin - Merci!

J'ai essayé les deux dans ma vraie application et j'ai obtenu des horaires pour eux - Voici les deux champs d'application:

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

Ran this avec une vraie application - petite table avec ~ 700 enregistrements 'Person' - moyenne de 5 essais

L'approche d'Unixmonkey ( :without_friends_v1) 813ms / requête

Approche de dmarkow ( :without_friends_v2) 891ms / requête (~ 10% plus lent)

Mais ensuite, je me suis rendu compte que je n'avais pas besoin de l'appel pour DISTINCT()...rechercher des Personenregistrements avec NON Contacts- ils doivent donc simplement être NOT INla liste des contacts person_ids. J'ai donc essayé cette portée:

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

Cela donne le même résultat mais avec une moyenne de 425 ms / appel - presque la moitié du temps ...

Maintenant, vous pourriez avoir besoin du DISTINCTdans d'autres requêtes similaires - mais pour mon cas, cela semble fonctionner correctement.

Merci de votre aide

Malheureusement, vous êtes probablement à la recherche d'une solution impliquant SQL, mais vous pouvez la définir dans une portée et ensuite simplement utiliser cette portée:

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

Ensuite, pour les obtenir, vous pouvez simplement le faire Person.without_friends, et vous pouvez également l'enchaîner avec d'autres méthodes Arel:Person.without_friends.order("name").limit(10)

Une sous-requête corrélée NOT EXISTS doit être rapide, en particulier lorsque le nombre de lignes et le ratio d'enregistrements enfants / parents augmentent.

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

Aussi, pour filtrer par un ami par exemple:

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