belongd_to proxy loads from database every time if record is missing

Greetings all,

I'm hitting some interesting behaviour in the association proxy code that seems to be intentional, but seems non-optimal and is actually causing quite a bit of unnecessary DB querying in our case.

Basically it looks like there is some special-casing of the BelongsToAssociation proxy to avoid setting its target to nil. In particular there are these lines in association.rb:

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

  if association.nil? || force_reload
    association = association_proxy_class.new(self, reflection)
    retval = association.reload
    if retval.nil? and association_proxy_class == BelongsToAssociation
      association_instance_set(reflection.name, nil)
      return nil
    end
    association_instance_set(reflection.name, association)
  end

  association.target.nil? ? nil : association
end

I can understand not returning the proxy when the target is nil, since the proxy can't impersonate nil. However, not setting the proxy into the instance variable means the DB will be requeried every time for no good reason, and it seems to me that assigning the proxy will still have the correct behaviour from the model's perspective. The same thing happens on preloading, meaning that preloading doesn't actually do anything for missing records.

Does anyone know the reason for this behaviour? I'm using Rails 2.3.2. Here's a reproduction of the problem from the application's perspective.

class Alpha < ActiveRecord::Base
end

class Beta < ActiveRecord::Base
  belongs_to :alpha
end

a = Alpha.create
b = Beta.create :alpha => a
a.destroy

b_loaded = Beta.find(b.id, :include => :alpha)
b_loaded.loaded_alpha?    # => false (or nil, rather, but not true)
b_loaded.alpha            # => nil
b_loaded.loaded_alpha?    # => still nil rather than true
b_loaded.alpha            # => nil (and hits the DB again)

Thanks!