counter_cache optimización has_many_through sql, reducir el número de consultas SQL

Question

¿Cómo puedo optimizar mis consultas SQL, hacer caso omiso de este tipo de situaciones:

Meeting.find (5) .users.size => SELECT COUNT (*) dE DONDE ... ...

User.find (123) .meetings.size => SELECT COUNT (*) Desde ... DONDE ...

no tengo ni idea de cómo utilizar counter_cache aquí.

Aquí es mi modelo de relación:

class Meeting < ActiveRecord::Base 
    has_many :meeting_users 
    has_many :users, :through => meeting_users 
end 

class User < ActiveRecord::Base 
    has_many :meeting_users 
    has_many :meetings, :through => meeting_users 
end 

class Meeting_user < ActiveRecord::Base 
    belongs_to :meeting 
    belongs_to :user 
end 

¿Cuáles son las soluciones más óptimas?

¿Y cómo implementar counter_cache aquí?

Answer 1

Hasta donde yo sé, no puede usar counter_cache con through asociaciones, es por eso que debe incrementarlo manualmente.

Por ejemplo (no probado):

class MeetingUser < ActiveRecord::Base 

    ... 

    after_create { |record| 
    Meeting.increment_counter(:users_count, record.meeting.id) 
    } 

    after_destroy { |record| 
    Meeting.decrement_counter(:users_count, record.meeting.id) 
    } 

end 

Answer 2

A partir de Rails3.0.5 y en las últimas versiones, que ahora son capaces de establecer caché en contra del modelo de "enlazador", en su caso, será:

class MeetingUser < ActiveRecord::Base 
    belongs_to :meeting, :counter_cache => :users_count 
    belongs_to :user, :counter_cache => :meetings_count 
end 

Es importante especificar explícitamente los nombres de las columnas de recuento, de lo contrario, las columnas utilizadas tendrán como valor predeterminado meeting_users_count.