Rails Associations - Séquence de rappel/Magie

Question

Prise déclaration suivante d'association à titre d'exemple:

class Post 
has_many :comments 
end 

Tout en déclarant les has_many: commentaires, ActiveRecord ajoute plusieurs méthodes dont je suis particulièrement intéressé par commentaires qui retourne un tableau des commentaires. J'ai parcouru le code et suivant semble être la séquence de rappel:

def has_many(association_id, options = {}, &extension) 
    reflection = create_has_many_reflection(association_id, options, &extension) 
    configure_dependency_for_has_many(reflection) 
    add_association_callbacks(reflection.name, reflection.options) 

    if options[:through] 
    collection_accessor_methods(reflection, HasManyThroughAssociation) 
    else 
    collection_accessor_methods(reflection, HasManyAssociation) 
    end 
end 

---

def collection_accessor_methods(reflection, association_proxy_class, writer = true) 
    collection_reader_method(reflection, association_proxy_class) 

    if writer 
    define_method("#{reflection.name}=") do |new_value| 
     # Loads proxy class instance (defined in collection_reader_method) if not already loaded 
     association = send(reflection.name) 
     association.replace(new_value) 
     association 
    end 

    define_method("#{reflection.name.to_s.singularize}_ids=") do |new_value| 
     ids = (new_value || []).reject { |nid| nid.blank? } 
     send("#{reflection.name}=", reflection.class_name.constantize.find(ids)) 
    end 
    end 
end 

---

def collection_reader_method(reflection, association_proxy_class) 
    define_method(reflection.name) do |*params| 
    force_reload = params.first unless params.empty? 
    association = association_instance_get(reflection.name) 

    unless association 
     association = association_proxy_class.new(self, reflection) 
     association_instance_set(reflection.name, association) 
    end 

    association.reload if force_reload 

    association 
    end 

    define_method("#{reflection.name.to_s.singularize}_ids") do 
    if send(reflection.name).loaded? || reflection.options[:finder_sql] 
     send(reflection.name).map(&:id) 
    else 
     send(reflection.name).all(:select => "#{reflection.quoted_table_name}.#{reflection.klass.primary_key}").map(&:id) 
    end 
    end 
end 

---

Dans cette séquence de callbacks, où est exactement le SQL réel en cours d'exécution pour récupérer les commentaires quand je fais @ post.comments?

Answer 1

Vous devez approfondir la définition de HasManyAssociation. Colletion_reader_method définit une méthode appelée commentaries sur votre classe Post.

Lorsque la méthode comments est appelée, elle s'assure qu'un objet proxy de la classe HasManyAssociation est stocké (vous devrez creuser dans la méthode association_instance_set pour voir exactement où elle le stocke), puis renvoie cet objet proxy.

Je présume que le SQL entre lorsque vous appelez une méthode sur le proxy, par exemple, appelez chacun, tous ou accédez à un index avec [].

Answer 2

Vous êtes: une requête standard AR obtenir tous les IDs des objets associés

send(reflection.name).all(:select => "#{reflection.quoted_table_name}.#{reflection.klass.primary_key}").map(&:id) 

mais vous activerecord est en désordre ... une nouvelle mise en œuvre (mieux sans eval) de has_many peut peut-être être utile pour vous:

def has_many(children) 
    send(:define_method, children){ eval(children.to_s.singularize.capitalize).all(:conditions => { self.class.name.downcase => name }) } 
end 

Answer 3

dans le lecteur d'association de la ligne

association = association_proxy_class.new(self, reflection) 

dans la salle d sera responsable de l'exécution de la recherche, lorsque la variable d'instance est "demandée" et "voit" que @loaded est faux.

Answer 4

Je ne suis pas sûr à 100% que je comprends ce que vous cherchez.

La génération sql n'est pas au même endroit en AR. Certaines choses spécifiques à la base de données se trouvent dans la base de données "connection_adapters".

Si vous cherchez comment les enregistrements se trouvent dans la base de données, regardez les méthodes "construct_finder_sql" et "add_joins" dans le module ActiveRecord :: Base.

def construct_finder_sql(options) 
     scope = scope(:find) 
     sql = "SELECT #{options[:select] || (scope && scope[:select]) || default_select(options[:joins] || (scope && scope[:joins]))} " 
     sql << "FROM #{(scope && scope[:from]) || options[:from] || quoted_table_name} " 

     add_joins!(sql, options[:joins], scope) 
     ... 

et

def add_joins!(sql, joins, scope = :auto) 
     scope = scope(:find) if :auto == scope 
     merged_joins = scope && scope[:joins] && joins ? merge_joins(scope[:joins], joins) : (joins || scope && scope[:joins]) 
     case merged_joins 
     when Symbol, Hash, Array 
     if array_of_strings?(merged_joins) 
      sql << merged_joins.join(' ') + " " 
     else 
      join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, merged_joins, nil) 
      sql << " #{join_dependency.join_associations.collect { |assoc| assoc.association_join }.join} " 
     end 
     when String 
     sql << " #{merged_joins} " 
     end 
    end 

J'espère que cela aide!