jak uniknąć duplikatów w relacji has_many: through?

Question

Jak mogę osiągnąć następujące czynności? Mam dwa modele (blogi i czytelników) oraz tabeli łączącej, która pozwoli mi mieć N: M relacji między nimi:

class Blog < ActiveRecord::Base 
    has_many :blogs_readers, :dependent => :destroy 
    has_many :readers, :through => :blogs_readers 
end 

class Reader < ActiveRecord::Base 
    has_many :blogs_readers, :dependent => :destroy 
    has_many :blogs, :through => :blogs_readers 
end 

class BlogsReaders < ActiveRecord::Base 
    belongs_to :blog 
    belongs_to :reader 
end 

co chcę teraz zrobić, to dodać czytelników do różnych blogów. Warunkiem jest jednak to, że mogę dodać czytelnika tylko do bloga RAZ. Więc nie może być żadnych duplikatów (ten sam readerID, ten sam blogID) w tabeli BlogsReaders. Jak mogę to osiągnąć?

Drugie pytanie brzmi: jak uzyskać listę blogów, których już nie subskrybują czytelnicy (np. Wypełnić listę wyboru, którą można następnie wykorzystać do dodania czytelnika do innego bloga) ?

Answer 1

Co o:

Blog.find(:all, 
      :conditions => ['id NOT IN (?)', the_reader.blog_ids]) 

Szyny dba o gromadzenie identyfikatorów dla nas z metodami stowarzyszenia! :)

http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html

Answer 2

To powinno dbać o swoje pierwsze pytanie:

class BlogsReaders < ActiveRecord::Base 
    belongs_to :blog 
    belongs_to :reader 

    validates_uniqueness_of :reader_id, :scope => :blog_id 
end 

Answer 3

myślę ktoś przyjdzie wraz z lepszą odpowiedź niż ta.

the_reader = Reader.find(:first, :include => :blogs) 

Blog.find(:all, 
      :conditions => ['id NOT IN (?)', the_reader.blogs.map(&:id)]) 

[edytuj]

Proszę zobaczyć odpowiedź Josha poniżej. To jest droga. (Wiedziałam, że lepszym sposobem tam;)

Answer 4

Prostsze rozwiązanie, które jest wbudowane w Rails:

class Blog < ActiveRecord::Base 
    has_many :blogs_readers, :dependent => :destroy 
    has_many :readers, :through => :blogs_readers, :uniq => true 
    end 

    class Reader < ActiveRecord::Base 
    has_many :blogs_readers, :dependent => :destroy 
    has_many :blogs, :through => :blogs_readers, :uniq => true 
    end 

    class BlogsReaders < ActiveRecord::Base 
     belongs_to :blog 
     belongs_to :reader 
    end 

Uwaga dodanie opcji do wywołania has_many:uniq => true.

Możesz również rozważyć has_and_belongs_to_many między blogiem a czytnikiem, chyba że masz inne atrybuty, które chciałbyś mieć w modelu łączenia (obecnie nie). Ta metoda ma także opiton :uniq.

Należy zauważyć, że to nie przeszkadza w tworzeniu wpisów w tabeli, ale zapewnia, że ​​przy zapytaniu o kolekcję otrzymasz tylko jeden z każdego obiektu.

Aktualizacja

W Rails 4 sposobem na to jest za pomocą bloku zakres. Powyżej zmienia się na.

class Blog < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :readers, -> { uniq }, through: :blogs_readers 
end 

class Reader < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :blogs, -> { uniq }, through: :blogs_readers 
end 

class BlogsReaders < ActiveRecord::Base 
    belongs_to :blog 
    belongs_to :reader 
end 

Answer 5

Odpowiedzią na ten link pokazuje jak zastąpić metodę „< <”, aby osiągnąć to, czego szukasz, nie podnosząc wyjątki lub utworzenie oddzielnego metody: Rails idiom to avoid duplicates in has_many :through

Answer 6

Najprostszym sposobem jest serializacji relację do tablicy:

class Blog < ActiveRecord::Base 
    has_many :blogs_readers, :dependent => :destroy 
    has_many :readers, :through => :blogs_readers 
    serialize :reader_ids, Array 
end 

Następnie podczas przypisywania wartości do czytelników, zastosować je jako

blog.reader_ids = [1,2,3,4] 

Podczas przypisywania relacji w ten sposób duplikaty są automatycznie usuwane.

Answer 7

szynach 5,1 sposobem

class Blog < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :readers, -> { distinct }, through: :blogs_readers 
end 

class Reader < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :blogs, -> { distinct }, through: :blogs_readers 
end 

class BlogsReaders < ActiveRecord::Base 
    belongs_to :blog 
    belongs_to :reader 
end 

Answer 8

Górny odpowiedź obecnie mówi używać uniq w proc:

class Blog < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :readers, -> { uniq }, through: :blogs_readers 
end 

To jednak kopie relacji do tablicy i może złamać rzeczy, które są spodziewa się wykonać operacje na relacji, a nie tablicy.

Jeśli używasz distinct utrzymuje go jako relacja:

class Blog < ActiveRecord::Base 
has_many :blogs_readers, dependent: :destroy 
has_many :readers, -> { distinct }, through: :blogs_readers 
end