Question

Is there a way to run code BEFORE model retrieval? I know about the after_find callback, but I need to run before. I’d also like it to run only ONCE per retrieval regardless of the number of records returned. Looking at the RoR source it seems the query is actually executed in exec_queries(or to_a) in ActiveRecord::Relation. Do/Should I override this method to add this hook?

And just in case I’m going about this all wrong, the reason I’m asking is I have an external REST API I am using to retrieve data, but it is too slow to retrieve after every page reload. I was originally using memcached, but I figured I could just use ActiveRecord to cache the data in a database so I can easily query the data and possibly join it with similar data from other REST APIs. I’d like to plug in a callback that would after a certain timeout duration, reload the data from REST before returning ActiveRecord results.

Basically I’m looking for the best way to centralize refreshing my database from another source (REST) instead of cluttering up my controllers or overriding every model accessor that I use (is there a way to override them all easily?). Perhaps the best solution lies here.

It appears all of the built in methods like all, find, first, and last call apply_finder_options (and then where), but the dynamically created finders (find_by_name, etc) call find_dynamic_match which eventually calls where. This is what lead me to the to_a method on the relation, since it is common and called when the query is actually executed, and not just when building a relation before a query is executed. However getting this low level in into Rails makes me uncomfortable.

It seems like my problem shouldn’t be an uncommon one, so perhaps my approach is wrong?

FYI, I’m new to rails and ruby. Thanks!

Answer 1

I would strongly advise against using a low-level hook in place of explicit cache checking. ActiveRecord has it’s own caching mechanism, but if that isn’t doing it for you and you need to build your own – use it explicitly before using ActiveRecord finders. Hooks like these can make it very confusing to determine what is happening and why, and is not a recommended practice. Here is an example using a proxy model:

class CacheProxy
  attr_accessor :klass
  def initialize(klass)
    @klass = klass
  end

  def method_missing(method_id, *arguments, &block)
    reload_if_necessary
    klass.send(method_id, *arguments, &block)
  end

  private
  def reload_if_necessary
    return unless needs_reload?
    # perform reload
  end

  def needs_reload?
    # determine if we need to reload the cache
  end
end

class ActiveRecord::Base
  def self.proxy
    CacheProxy.new(self)
  end
end

Now you can even do MyModel.proxy.find_by_first_name_and_last_name('John', 'Doe')