Browse: Home / , , / Better in-memory associations with :inverse_of

Better in-memory associations with :inverse_of

By hakunin on May 5, 2009

Today Rails gained a very interesting commit from h-lame. It’s the first major step towards making associations aware of their parent model while still in-memory. A few days ago I started this discussion which revealed to me that it had been a long time coming, just no one bothered.

Well, finally someone did. I would like to thank h-lame for making this commit happen. Here’s the excerpt from the commit message.

You can now add an :inverse_of option to has_one, has_many and belongs_to associations. This is best described with an example:

      class Man < ActiveRecord::Base
        has_one :face, :inverse_of => :man
      end

      class Face < ActiveRecord::Base
        belongs_to :man, :inverse_of => :face
      end

      m = Man.first
      f = m.face
Without :inverse_of m and f.man would be different instances of the same object (f.man being pulled from the database again).

Posted in , ,

5 responses to “Better in-memory associations with :inverse_of”

  1. Clay Shentrup
    Clay Shentrup
    June 12, 2010 at 17:40 | | Reply

    Can you explain how inverse_of is in any way necessary? The relationships are already described via has_one and belongs_to.

    1. hakunin
      hakunin
      June 12, 2010 at 17:49 | | Reply

      Currently all relationship are one-way. A practical explanation would be that if you have:

      

      class Horse
      
  belongs_to :rider
      
end
      

      
class Rider
      
  has_many :horses
      
end
      

      
# controller
      
@riders = Rider.all(:include => :horses)

      You will end up eager-loading both riders and horses, that’s great. So @riders.first.horse will not run any extra SQL queries. However, @riders.first.horse.rider will run an additional query to fetch the horse’s rider. Because Rails won’t know that they should be the same object. The comprehensive solution would be an identity map, but this commit was a start in the right direction.

      1. Sokolov Yura
        Sokolov Yura
        August 4, 2010 at 18:03 | | Reply

        I wrote simple “identity map” capable to do job of :inverse_of. Also, it helps to save memory by updating attributes of already fetched objects, instead of creating new instances.

        gem is ar-simple-idmap repository: http://github.com/funny-falcon/identity-map

  2. Michael Durrant
    Michael Durrant
    August 8, 2012 at 12:58 | | Reply

    Clay you are correct that “The relationships are already described via has_one and belongs_to.”

    I believe that what is actually being addressed here is basically a performance issue, i.e. the current system works ok but could be more efficient. In this case it’s about memory and the second instantiation of the object being unnecessary and wastful when the first could be reused.

  3. Sathya Sekaran
    Sathya Sekaran
    December 28, 2012 at 15:22 | | Reply

    It’s not just a performance issue. Say if you’re saving a model and you want the associated model to be aware of pending changes to the parent model. That’s not easily possible without this.

Leave a Reply