Ingin menemukan catatan tanpa catatan terkait di Rails

Pertimbangkan asosiasi sederhana ...

class Person
   has_many :friends
end

class Friend
   belongs_to :person
end

Apa cara paling bersih untuk mendapatkan semua orang yang TIDAK memiliki teman di ARel dan / atau meta_where?

Lalu bagaimana dengan has_many: melalui versi

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

Saya benar-benar tidak ingin menggunakan counter_cache - dan saya dari apa yang saya baca tidak bekerja dengan has_many: through

Saya tidak ingin menarik semua catatan person.friends dan mengulanginya di Ruby - Saya ingin memiliki kueri / lingkup yang dapat saya gunakan dengan permata meta_search

Saya tidak keberatan dengan biaya kinerja dari kueri

Dan semakin jauh dari SQL aktual semakin baik ...

Ini masih cukup dekat dengan SQL, tetapi harus membuat semua orang tanpa teman dalam kasus pertama:

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

Lebih baik:

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

Untuk hmt pada dasarnya hal yang sama, Anda bergantung pada kenyataan bahwa seseorang tanpa teman juga tidak akan memiliki kontak:

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

Memperbarui

Punya pertanyaan tentang has_onedi komentar, jadi baru saja memperbarui. Kuncinya di sini adalah bahwa includes()mengharapkan nama asosiasi tetapi wheremengharapkan nama tabel. Untuk suatu has_oneasosiasi umumnya akan diekspresikan dalam bentuk tunggal, sehingga berubah, tetapi where()bagian tetap seperti itu. Jadi, jika Personhanya satu has_one :contactmaka pernyataan Anda adalah:

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

Perbarui 2

Seseorang bertanya tentang kebalikannya, teman tanpa orang. Seperti yang saya komentari di bawah ini, ini benar-benar membuat saya menyadari bahwa bidang terakhir (di atas: the :person_id) tidak benar-benar harus terkait dengan model yang Anda kembalikan, hanya harus berupa bidang di tabel bergabung. Mereka semua akan niljadi bisa salah satu dari mereka. Ini mengarah ke solusi yang lebih sederhana untuk yang di atas:

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

Dan kemudian beralih ini untuk mengembalikan teman tanpa orang menjadi lebih sederhana, Anda hanya mengubah kelas di depan:

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

Perbarui 3 - Rel 5

Terima kasih kepada @Anson untuk solusi Rails 5 yang sangat baik (beri dia +1 untuk jawabannya di bawah), Anda dapat menggunakan left_outer_joinsuntuk menghindari memuat asosiasi:

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

Saya sudah memasukkannya di sini sehingga orang-orang akan menemukannya, tetapi dia layak mendapatkan +1 untuk ini. Tambahan yang bagus!

Pembaruan 4 - Rel 6.1

Terima kasih kepada Tim Park karena telah menunjukkan bahwa pada 6.1 mendatang Anda dapat melakukan ini:

Person.where.missing(:contacts)

Berkat pos yang dia tautkan juga.

smathy memiliki jawaban Rails 3 yang bagus.

Untuk Rails 5 , Anda dapat menggunakan left_outer_joinsuntuk menghindari memuat asosiasi.

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

Lihat dokumen api . Itu diperkenalkan dalam permintaan tarik # 12071 .

Orang yang tidak memiliki teman

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

Atau yang memiliki setidaknya satu teman

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

Anda dapat melakukan ini dengan Arel dengan menyiapkan cakupan 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

Dan kemudian, Orang yang memiliki setidaknya satu teman:

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

The friendless:

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

Baik jawaban dari dmarkow dan Unixmonkey memberi saya apa yang saya butuhkan - Terima kasih!

Saya mencoba keduanya di aplikasi asli saya dan mendapatkan timing untuk mereka - Berikut adalah dua cakupannya:

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

Jalankan ini dengan aplikasi nyata - meja kecil dengan ~ 700 catatan 'Person' - rata-rata 5 berjalan

Pendekatan Unixmonkey ( :without_friends_v1) 813ms / permintaan

pendekatan dmarkow ( :without_friends_v2) 891ms / permintaan (~ 10% lebih lambat)

Tetapi kemudian terlintas dalam benak saya bahwa saya tidak memerlukan panggilan untuk DISTINCT()...mencari Personcatatan dengan TIDAK Contacts- jadi mereka hanya perlu menjadi NOT INdaftar kontak person_ids. Jadi saya mencoba cakupan ini:

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

Itu mendapatkan hasil yang sama tetapi dengan rata-rata 425 ms / panggilan - hampir separuh waktu ...

Sekarang Anda mungkin perlu DISTINCTdalam pertanyaan serupa lainnya - tetapi untuk kasus saya ini sepertinya berfungsi dengan baik.

Terima kasih atas bantuan Anda

Sayangnya, Anda mungkin melihat solusi yang melibatkan SQL, tetapi Anda bisa mengaturnya dalam lingkup dan kemudian gunakan lingkup itu:

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

Kemudian untuk mendapatkannya, Anda bisa melakukannya Person.without_friends, dan Anda juga bisa mengaitkannya dengan metode Arel lainnya:Person.without_friends.order("name").limit(10)

A TIDAK ADA subquery berkorelasi harus cepat, terutama karena jumlah baris dan rasio catatan anak ke orang tua meningkat.

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

Juga, untuk memfilter oleh satu teman misalnya:

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