Desideri trovare record senza record associati in Rails

Prendi in considerazione una semplice associazione ...

class Person
   has_many :friends
end

class Friend
   belongs_to :person
end

Qual è il modo più pulito per ottenere tutte le persone che NON hanno amici in ARel e / o meta_where?

E poi che dire di un has_many: attraverso la versione

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

Non voglio davvero usare counter_cache - e da quello che ho letto non funziona con has_many: through

Non voglio estrarre tutti i record person.friends e sfogliarli in Ruby: voglio avere una query / ambito che posso usare con la gemma meta_search

Non mi dispiace il costo delle prestazioni delle query

E più lontano dall'attuale SQL, meglio è ...

Questo è ancora abbastanza vicino a SQL, ma nel primo caso dovrebbe portare tutti senza amici:

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

Meglio:

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

Per l'hmt è sostanzialmente la stessa cosa, fai affidamento sul fatto che una persona senza amici non avrà contatti:

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

Aggiornare

Hai una domanda has_onenei commenti, quindi solo l'aggiornamento. Il trucco qui è che si includes()aspetta il nome dell'associazione ma ilwhere aspetta il nome della tabella. Per a has_onel'associazione sarà generalmente espressa al singolare, in modo che cambi, ma la where()parte rimane così com'è. Quindi, se Personsolo has_one :contactallora la tua affermazione sarebbe:

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

Aggiornamento 2

Qualcuno ha chiesto del contrario, amici senza gente. Come ho commentato di seguito, questo in realtà mi ha fatto capire che l'ultimo campo (sopra: il :person_id) in realtà non deve essere correlato al modello che stai restituendo, deve solo essere un campo nella tabella di join. Lo saranno tutti, nilquindi può essere uno di loro. Questo porta a una soluzione più semplice di quanto sopra:

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

E poi cambiando questo per restituire gli amici senza persone diventa ancora più semplice, cambi solo la classe in primo piano:

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

Aggiornamento 3 - Rotaie 5

Grazie a @Anson per l'eccellente soluzione Rails 5 (dategli alcuni +1 per la sua risposta di seguito), potete usare left_outer_joinsper evitare di caricare l'associazione:

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

L'ho incluso qui, così la gente lo troverà, ma per questo merita i +1. Grande aggiunta!

Aggiornamento 4 - Rotaie 6.1

Grazie a Tim Park per aver sottolineato che nella prossima 6.1 puoi farlo:

Person.where.missing(:contacts)

Grazie al post a cui è collegato anche lui.

smathy ha una buona risposta su Rails 3.

Per Rails 5 , è possibile utilizzare left_outer_joinsper evitare il caricamento dell'associazione.

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

Dai un'occhiata ai documenti API . È stato introdotto nella richiesta pull n . 12071 .

Persone che non hanno amici

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

O che hanno almeno un amico

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

Puoi farlo con Arel impostando gli ambiti su 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

E poi, le persone che hanno almeno un amico:

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

I senza amici:

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

Entrambe le risposte di dmarkow e Unixmonkey mi danno ciò di cui ho bisogno - Grazie!

Ho provato entrambi nella mia app reale e ho avuto i tempi per loro - Ecco i due ambiti:

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

Ho corso con un'app reale - tavolino con ~ 700 record "Person" - media di 5 corse

Approccio di Unixmonkey ( :without_friends_v1) 813ms / query

Approccio di dmarkow ( :without_friends_v2) 891ms / query (~ 10% più lento)

Ma poi mi è venuto in mente che non ho bisogno della chiamata per DISTINCT()...cercare Personrecord con NO Contacts, quindi devono solo essere NOT INl'elenco dei contatti person_ids. Quindi ho provato questo ambito:

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

Questo ottiene lo stesso risultato ma con una media di 425 ms / chiamata - quasi la metà del tempo ...

Ora potresti aver bisogno di DISTINCT di altre domande simili, ma per il mio caso questo sembra funzionare bene.

Grazie per l'aiuto

Sfortunatamente, stai probabilmente esaminando una soluzione che coinvolge SQL, ma potresti impostarla in un ambito e quindi utilizzare tale ambito:

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

Quindi per ottenerli, puoi semplicemente farlo Person.without_friendse puoi anche concatenarlo con altri metodi Arel:Person.without_friends.order("name").limit(10)

Una sottoquery correlata NON ESISTE dovrebbe essere veloce, in particolare all'aumentare del numero di righe e del rapporto tra i record figlio e genitore.

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

Inoltre, per filtrare ad esempio un amico:

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