Question

Even though I know that, at least to my knowledge, this is not the default way of doing associations with ActiveRecord I’m looking for help in order to implement an “hibernatish” Polymorphic model.

For instance, consider the following base model:

# Content only has one property named path
class Content < ActiveRecord::Base
  self.abstract_class = true
end

And the concrete content:

# Audio only has one property on it's own (duration).
# However, it should also inherit Content's property (path)
class Audio < Content
end

Now, something relatively interesting happens when using ActiveRecord, more accurately Rails 3 beta 3 ActiveRecord. If you set the abstract_class to false on the Content model and you execute the following:

Audio.create!(:path => '/dev/null')

It kinda works from an Hibernate perspective. That is, a Content record is created with ID 1 and an Audio record is also created with the ID = 1.

However, the problem #1 is that in order for this to work, you obviously need to turnoff the abstract_class, which kinda breaks the whole point of this abstract content example.

Furthermore, the problem #2 is that if you turn on the abstract_class you lose the content’s properties when creating instances of Audio. And, if you turn it off, you lose the Audio properties when creating an instance of Audio.

Ideally, when faced with an abstract class that is then subclassed, ActiveRecord would provide the abstract + concrete properties to the concrete class being instantiated, in this case Audio. Effectively, that way, when creating an instance of Audio we would have:

audio = Audio.new #=> <Audio id: nil, duration: nil, path: nil, created_at: nil, updated_at: nil> 

And then [naturally] when you assign audio.path = ‘/dev/null’ and performed a save operation, ActiveRecord would know that the path attribute has been inherited, thus needs to be persisted at the parent class level. Furthermore, on that same save operation, should you set a non inherited property of audio ActiveRecord would also persist those changes in the audios table.

My question, after this introduction, is how one could go around active record and enhance it that way?

Effectively, let’s assume that we’re developing a gem that aims to provide active record with this kind of functionality. How would you go about and do it?

PS: I’m actually considering to develop such gem, though such hackery shouldn’t go by without prior thinking. So, your feedback is most welcomed.

Best regards,
DBA

Answer 1

I see what you’re going for here, but unfortunately I don’t think you can get this to work out of the box the way you’d like.

Basically ActiveRecord uses model inheritance for two things:

• Abstract classes, from which subclasses can inherit code and behavior but NOT table structure. You could implement a #path attribute on Content using attr_accessor and it would be inherited by subclasses, but it would not be persisted to the database unless the table for your model subclass had a ‘path’ column.

• Single table inheritance, where subclasses inherit both behavior and table persistence.

You can mix the two, but there is no scenario where an ActiveRecord model can inherit a persistable column from an abstract class. There’s always a 1:1 mapping between persisted attributes and table columns.