Chcesz znaleźć rekordy bez powiązanych rekordów w Railsach

Rozważ proste skojarzenie ...

class Person
   has_many :friends
end

class Friend
   belongs_to :person
end

Jaki jest najczystszy sposób na zdobycie wszystkich osób, które NIE mają przyjaciół w ARel i / lub meta_where?

A co z has_many: poprzez wersję

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

Naprawdę nie chcę używać counter_cache - i z tego, co przeczytałem, nie działa z has_many: przez

Nie chcę pobierać wszystkich rekordów person.friends i przeglądać je w Rubim - chcę mieć zapytanie / zakres, którego mogę użyć z gemem meta_search

Nie przeszkadza mi koszt wydajności zapytań

Im dalej od rzeczywistego SQL, tym lepiej ...

Jest to nadal bardzo zbliżone do SQL, ale w pierwszym przypadku powinno przyciągnąć wszystkich bez znajomych:

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

Lepszy:

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

Hmt to w zasadzie to samo, polegasz na tym, że osoba bez przyjaciół również nie będzie miała kontaktów:

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

Aktualizacja

Mam pytanie has_onew komentarzach, więc po prostu aktualizuję. Sztuczka polega na tym, że includes()oczekuje nazwy skojarzenia, ale whereoczekuje nazwy tabeli. W przypadku a has_oneskojarzenie będzie zazwyczaj wyrażane w liczbie pojedynczej, więc zmienia się, ale where()część pozostaje taka, jaka jest. Więc jeśli Persontylko has_one :contactwtedy twoje oświadczenie byłoby:

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

Zaktualizuj 2

Ktoś zapytał o odwrotność, przyjaciół bez ludzi. Jak skomentowałem poniżej, to faktycznie uświadomiło mi, że ostatnie pole (powyżej: the :person_id) tak naprawdę nie musi być związane z modelem, który zwracasz, po prostu musi to być pole w tabeli łączenia. Wszyscy będą, nilwięc może to być każdy z nich. Prowadzi to do prostszego rozwiązania powyższego:

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

A potem przełączenie tego, aby zwrócić przyjaciół bez ludzi, staje się jeszcze prostsze, zmieniasz tylko klasę z przodu:

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

Aktualizacja 3 - Rails 5

Dzięki @Anson za doskonałe rozwiązanie Rails 5 (daj mu kilka + 1-ek za jego odpowiedź poniżej), możesz użyć, left_outer_joinsaby uniknąć ładowania skojarzenia:

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

Umieściłem go tutaj, aby ludzie go mogli znaleźć, ale zasługuje na +1 za to. Świetny dodatek!

Aktualizacja 4 - Rails 6.1.0

Podziękowania dla Tima Park za wskazanie, że w nadchodzącym 6.1 możesz to zrobić:

Person.where.missing(:contacts)

Dzięki postowi, do którego też się podlinkował

Smathy ma dobrą odpowiedź Rails 3.

W przypadku Rails 5 możesz użyć, left_outer_joinsaby uniknąć ładowania skojarzenia.

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

Zapoznaj się z dokumentacją API . Został wprowadzony w żądaniu ściągnięcia nr 12071 .

Osoby, które nie mają przyjaciół

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

Albo co najmniej jednego przyjaciela

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

Możesz to zrobić z Arel, ustawiając zakresy na 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

A następnie Osoby, które mają co najmniej jednego znajomego:

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

Bez przyjaciół:

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

Odpowiedzi z dmarkow i Unixmonkey dają mi to, czego potrzebuję - dziękuję!

Wypróbowałem oba w mojej prawdziwej aplikacji i uzyskałem dla nich czasy - oto dwa zakresy:

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

Uruchomiłem to z prawdziwą aplikacją - małym stolikiem z ~ 700 rekordami „osób” - średnio 5 przebiegów

Podejście Unixmonkey ( :without_friends_v1) 813ms / query

podejście dmarkow ( :without_friends_v2) 891ms / zapytanie (~ 10% wolniej)

Ale wtedy przyszło mi do głowy, że nie potrzebuję telefonu do DISTINCT()...którego szukam Personpłyt z NIE Contacts- więc wystarczy, że są NOT INlistą kontaktów person_ids. Więc wypróbowałem ten zakres:

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

Daje to ten sam wynik, ale ze średnią 425 ms / połączenie - prawie połowę czasu ...

Teraz możesz potrzebować DISTINCTw innych podobnych zapytaniach - ale w moim przypadku wydaje się to działać dobrze.

Dzięki za pomoc

Niestety, prawdopodobnie szukasz rozwiązania wykorzystującego SQL, ale możesz ustawić je w zakresie, a następnie po prostu użyć tego zakresu:

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

Następnie, aby je zdobyć, możesz po prostu zrobić Person.without_friends, a także możesz połączyć to z innymi metodami Arela:Person.without_friends.order("name").limit(10)

Podzapytanie skorelowane NIE ISTNIEJE powinno być szybkie, zwłaszcza gdy wzrasta liczba wierszy i stosunek rekordów potomnych do nadrzędnych.

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

Ponadto, aby odfiltrować na przykład według jednego znajomego:

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