Rails Associations - Callback Sequence/Magic

Question

Taking following association declaration as an example:

class Post
 has_many :comments
end

Just by declaring the has_many :comments, ActiveRecord adds several methods of which I am particularly interested in comments which returns array of comments. I browsed through the code and following seems to be the callback sequence:

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

---

In this sequence of callbacks, where exactly is the actual SQL being executed for retrieving the comments when I do @post.comments ?

Answer 1

Here you are: a standard AR query getting all the ids of the associated objects

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

but sure Activerecord is messy... a re-implementation (better without eval) of has_many maybe can be useful for you:

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

Answer 2

In the association reader the line

association = association_proxy_class.new(self, reflection)

in the end will be responsible for executing the find, when the instance variable is "asked" for and "sees" that @loaded is false.

Answer 3

You need to dig deeper into the definition of HasManyAssociation.

colletion_reader_method defines a method called comments on your Post class. When the comments method is called, it ensures there's a proxy object of class HasManyAssociation stored away (you'll need to dig into the association_instance_set method to see where exactly it stores it), it then returns this proxy object.

I presume the SQL comes in when you call a method on the proxy, for example, calling each, all or accessing an index with [].

Answer 4

I am not 100% sure I understand what you are looking for.

The sql generation is not in one place in AR. Some of the database specific things are in the database "connection_adapters".

If you are looking for the way how the records are found in the database, look at the methods "construct_finder_sql" and "add_joins" in the ActiveRecord::Base module.

    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)
      ...

and

    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

I hope this helps!