Sie möchten in Rails 3 Datensätze ohne verknüpfte Datensätze finden

Betrachten Sie einen einfachen Verband...

class Person
   has_many :friends
end

class Friend
   belongs_to :person
end

Was ist der sauberste Weg, um alle Personen, die KEINE Freunde haben, die in ARel und/oder meta_where?

Und was ist dann eine 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

Ich wirklich nicht wollen, zu verwenden counter_cache - und ich von dem, was ich gelesen habe, es funktioniert nicht mit has_many :through

Ich will nicht zu ziehen den ganzen person.friends records und eine Schleife in Ruby - ich möchte eine Abfrage/Rahmen, die ich verwenden können, mit der meta_search gem

Ich nicht Sinn der Leistung Kosten der Abfragen

Und je weiter Weg vom eigentlichen SQL-desto besser...

InformationsquelleAutor der Frage craic.com | 2011-03-15

82

Dies ist immer noch ziemlich nahe an SQL, aber es sollte jeder mit keine Freunde in der erste Fall:
```
Person.where('id NOT IN (SELECT DISTINCT(person_id) FROM friends)')
```
InformationsquelleAutor der Antwort Unixmonkey
342

Besser:
```
Person.includes(:friends).where( :friends => { :person_id => nil } )
```
Für die hmt, es ist im Grunde die gleiche Sache, die Sie verlassen sich auf die Tatsache, dass eine person mit keine Freunde haben auch keine Kontakte:
```
Person.includes(:contacts).where( :contacts => { :person_id => nil } )
```
Update

Haben Sie eine Frage zu has_one in den Kommentaren, so dass nur der Aktualisierung. Der trick hier ist, dass includes() erwartet den Namen des Vereins, aber die where erwartet den Namen der Tabelle. Für eine has_one der Verein wird in der Regel ausgedrückt in der Einzahl, so dass die änderungen, aber die where() Teil bleibt wie es ist. Also, wenn ein Person nur has_one :contact dann Ihre Aussage wäre:
```
Person.includes(:contact).where( :contacts => { :person_id => nil } )
```
Update 2

Jemand fragte über die inverse, Freunde mit keine Menschen. Wie ich unten kommentiert, dieser tatsächlich machte mir klar, dass das Letzte Feld (oben::person_id) tatsächlich nicht mit dem Modell, die Sie zurückgeben, es hat nur ein Feld in der join-Tabelle. Sie sind alle gehen, um nil so kann es jedem von Ihnen. Dies führt zu einer einfacheren Lösung zu den oben genannten:
```
Person.includes(:contacts).where( :contacts => { :id => nil } )
```
Und dann wechseln diese die Rückkehr der Freunde, ohne Menschen wird auch einfacher, Sie ändern nur die Klasse an der front:
```
Friend.includes(:contacts).where( :contacts => { :id => nil } )
```
Update 3 - Schienen 5

Dank @Anson für die hervorragende Rails-5-Lösung (gib ihm ein paar +1s für seine Antwort weiter unten), können Sie left_outer_joins zu vermeiden, laden der Verein:
```
Person.left_outer_joins(:contacts).where( contacts: { id: nil } )
```
Habe ich es hier, damit die Leute es finden, aber er verdient den +1s. Tolle Ergänzung!

InformationsquelleAutor der Antwort smathy
84

smathy hat eine gute Rails 3 ist die Antwort.

Für Schienen 5, die Sie verwenden können left_outer_joins zu vermeiden, laden der Verein.
```
Person.left_outer_joins(:contacts).where( contacts: { id: nil } )
```
Check-out die api-docs. Eingeführt wurde Sie im pull-request #12071.

InformationsquelleAutor der Antwort Anson

Personen, die keine Freunde haben

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

Oder mit mindestens einem Freund

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

Können Sie dies mit Arel durch die Einrichtung von Verwaltungsbereichen für 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

Und dann, für Personen, die mindestens einen Freund:

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

Den friendless:

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

InformationsquelleAutor der Antwort novemberkilo

10

Sowohl die Antworten von dmarkow und Unixmonkey mir, was ich brauche - Danke!!!

Ich habe sowohl in meinem real-app und bekam timings für Sie - Hier sind die zwei Bereiche:
```
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
```
Lief mit einem "richtigen" app - kleiner Tisch mit ~700 "Personen" - Datensätze - Durchschnitt von 5 läuft

Unixmonkey Ansatz (:without_friends_v1) 813ms /Abfrage

dmarkow Ansatz (:without_friends_v2) 891ms /Abfrage (~ 10% langsamer)

Aber dann fiel mir ein, dass ich nicht brauchen, den Anruf zu DISTINCT()... ich bin auf der Suche nach Person Datensätze mit KEINE Contacts - also Sie müssen nur NOT IN die Liste der Kontakt person_ids. So habe ich versucht, dieses Umfang:
```
  scope :without_friends_v3, -> { where("id NOT IN (SELECT person_id FROM contacts)") }
```
, Erhält das gleiche Ergebnis, aber mit einem Durchschnitt von 425 ms/Aufruf - fast die Hälfte der Zeit...

Nun brauchst du die DISTINCT in anderen ähnlichen Abfragen - aber für meinen Fall scheint dies gut zu funktionieren.

Vielen Dank für Ihre Hilfe

InformationsquelleAutor der Antwort craic.com
5

Leider sind Sie wahrscheinlich auf der Suche auf eine Lösung mit SQL, aber Sie können legen Sie es in einen Rahmen und dann nur mit, dass Umfang:
```
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
```
Dann, Sie zu erhalten, können Sie nur Person.without_friends, und Sie können auch die Kette mit anderen Arel Methoden: Person.without_friends.order("name").limit(10)

InformationsquelleAutor der Antwort Dylan Markow
1

Auch, heraus zu filtern, von einem Freund zum Beispiel:
```
Friend.where.not(id: other_friend.friends.pluck(:id))
```
InformationsquelleAutor der Antwort Dorian
0

Einer not EXISTS korrelierte Unterabfrage sollte schnell sein, besonders, da die Zeilenanzahl und das Verhältnis von untergeordneten zu übergeordneten Datensätzen erhöht.
```
scope :without_friends, where("NOT EXISTS (SELECT null FROM contacts where contacts.person_id = people.id)")
```
InformationsquelleAutor der Antwort David Aldridge

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Update

Update 2

Update 3 - Schienen 5