Question

I’ve created an instance variable on an ActiveRecord Model where I want to save a bit of computationally heavy data in each instance… Here’s my code to do that:

class Account < ActiveRecord::Base

  after_initialize :init
  attr_accessor :market_value

  def init
    self.market_value ||= my_lengthy_function
  end
end

where I’ll take the hit to get that instance data (market_value) run when I init an instance of the model.

This works – I can see how I don’t have to re-calculate my market_value property.

My problem is, when I access that object through another context, rails doesn’t leverage that data as I’d expect.

For example:

Say I create an instance of an account (a = Account.find_by_id(2)). That market_value will be calculated on that object once.

If I have a nested has_many relationship to something called “holdings” (not in my sample code) on that account object, I’m going to want each of those holding objects (a holding) to be able to use it’s parent account object.

However, in my code, I access the account from it’s nested holding objects (my_holding.account.market_value) – I re-instantiate an instance of that account object, and incur that costly computation, even though it’s already been computed.

How can I better leverage that account market_value property so that it doesn’t keep recalculating?

Answer 1

I would not put the calculation logic in the ActiveRecord model. Maybe something along these lines:

class MarketValueCalculator

  def initialize()
    @market_values = {}
  end

  def calculate_for_account(account)
    @market_values[account.id] ||= heavy_lifting
  end

  def heavy_lifting
    ###
  end

end

@calculator = MarketValueCalculator.new

@market_value = @calculator.calculate_for_account(account)

@market_value = @calculator.calculate_for_account(my_holding.account)